diff --git a/.gitattributes b/.gitattributes index c69e378d2d..a9bf48ad05 100644 --- a/.gitattributes +++ b/.gitattributes @@ -23,6 +23,7 @@ *.sln text eol=lf *.targets text eol=lf *.yml text eol=lf +*.hlsl text eof=lf ############################################################################### # Set explicit file behavior to: @@ -53,10 +54,35 @@ *.7z binary *.ttf binary *.stout binary +*.p7s binary +*.sample binary +*.nupkg binary +*.exe binary +*.idx binary +*.pack binary +*.spv binary +*.lib binary +*.dylib binary *.so binary *.dll binary -*.dylib binary +*.xcscheme binary +*.xcworkspacedata binary +*.pdf binary +*.pfx binary +*.metal binary *.jar binary +*.apk binary +*.aar binary +*.aidl binary +*.flata binary +*.metallib binary +*.items binary +*.stamp binary +*.icns binary +*.mdb binary +*.pdb binary +*.bmp binary +*.dat binary # Verify *.verified.txt text eol=lf working-tree-encoding=UTF-8 diff --git a/.github/workflows/publish-site.yml b/.github/workflows/publish-site.yml index af72957721..7fc2ac4d3a 100644 --- a/.github/workflows/publish-site.yml +++ b/.github/workflows/publish-site.yml @@ -13,7 +13,15 @@ jobs: Build: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 + - name: Setup .NET 8 + uses: actions/setup-dotnet@v3 + with: + dotnet-version: '8.0.x' + - name: Setup .NET 9 + uses: actions/setup-dotnet@v3 + with: + dotnet-version: '9.0.102' - name: Build Website run: | git submodule update --init eng/submodules/silk.net-2.x diff --git a/.silktouch/0afb5dc84012c2fa.stout b/.silktouch/0afb5dc84012c2fa.stout deleted file mode 100644 index 60fd812b22..0000000000 Binary files a/.silktouch/0afb5dc84012c2fa.stout and /dev/null differ diff --git a/.silktouch/91c9aa14a031651f.stout b/.silktouch/91c9aa14a031651f.stout new file mode 100644 index 0000000000..45049cd1a2 Binary files /dev/null and b/.silktouch/91c9aa14a031651f.stout differ diff --git a/.silktouch/c8c046b328b09d23.stout b/.silktouch/c8c046b328b09d23.stout index 2f5d1a8ee3..8910217dea 100644 Binary files a/.silktouch/c8c046b328b09d23.stout and b/.silktouch/c8c046b328b09d23.stout differ diff --git a/Directory.Build.props b/Directory.Build.props index bf5682339b..2402e0f69e 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -67,6 +67,7 @@ SilkShippingControl;$(PackageVersionDependsOn) SilkNativePackaging;$(TargetsForTfmSpecificContentInPackage) SilkShippingControl;$(GenerateNuspecDependsOn) + false diff --git a/Directory.Packages.props b/Directory.Packages.props index 0772cba672..68748b13c8 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -19,6 +19,9 @@ + + + diff --git a/Silk.NET.sln b/Silk.NET.sln index 139e7f1fac..17850fdc6f 100644 --- a/Silk.NET.sln +++ b/Silk.NET.sln @@ -13,6 +13,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution LICENSE.md = LICENSE.md generator.json = generator.json Silk.NET.sln.DotSettings = Silk.NET.sln.DotSettings + Directory.Packages.props = Directory.Packages.props EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{9DB0EA3E-7216-4F9C-98F5-8A7483E9F083}" @@ -97,6 +98,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Win32", "Win32", "{6E739132 EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.SDL.Native", "sources\SDL\Native\Silk.NET.SDL.Native.csproj", "{F16C0AB9-DE7E-4C09-9EE9-DAA8B8E935A6}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Windowing", "Windowing", "{FE4414F8-5370-445D-9F24-C3AD3223F299}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Windowing", "sources\Windowing\Windowing\Silk.NET.Windowing.csproj", "{EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -159,6 +164,10 @@ Global {F16C0AB9-DE7E-4C09-9EE9-DAA8B8E935A6}.Debug|Any CPU.Build.0 = Debug|Any CPU {F16C0AB9-DE7E-4C09-9EE9-DAA8B8E935A6}.Release|Any CPU.ActiveCfg = Release|Any CPU {F16C0AB9-DE7E-4C09-9EE9-DAA8B8E935A6}.Release|Any CPU.Build.0 = Release|Any CPU + {EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -189,6 +198,8 @@ Global {6FA628B8-9696-4847-89F9-E58F470AF4FB} = {5CD096DB-6C44-48F1-9093-AD4C84B6B7EC} {6E739132-EEAB-43A5-83C7-EB58C50D03A1} = {DD29EA8F-B1A6-45AA-8D2E-B38DA56D9EF6} {F16C0AB9-DE7E-4C09-9EE9-DAA8B8E935A6} = {EC4D7B06-D277-4411-BD7B-71A6D37683F0} + {FE4414F8-5370-445D-9F24-C3AD3223F299} = {DD29EA8F-B1A6-45AA-8D2E-B38DA56D9EF6} + {EF07CBB5-D253-4CA9-A5DA-8B3DF2B0DF8E} = {FE4414F8-5370-445D-9F24-C3AD3223F299} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {78D2CF6A-60A1-43E3-837B-00B73C9DA384} diff --git a/docs/for-contributors/Windowing/Implementations/SDL3/event-pump.md b/docs/for-contributors/Windowing/Implementations/SDL3/event-pump.md new file mode 100644 index 0000000000..066ae66c93 --- /dev/null +++ b/docs/for-contributors/Windowing/Implementations/SDL3/event-pump.md @@ -0,0 +1,18 @@ +# The Event Pump + +The largest influence in the `ISurfaceApplication` design is the fact that for many platforms only the entry thread is +allowed to interact with the window manager (e.g. for the purposes of events). This creates a problem because rendering +is very much not single-threaded, nor are most use cases where the user has multiple windows. As such, +`ISurfaceApplication` gives the implementation freedom to decide what the most appropriate thread is to call into the +surface to raise events. This is further emphasised by the definition of `ISurfaceChildren` where the user can only +`Spawn` a surface, and not have a blocking call they can send off to their own thread. This allows the child windows to +use the same event thread and synchronization. This is likely inconvenient for rendering scenarios though +(e.g. for OpenGL where it's one thread per context/window, but all surfaces use the same thread by default...), for +which I expect that we'll add the ability to multithread for certain events in `SurfaceTimingOptions` or +`SurfaceTickOptions`. This however has been excluded from the initial 3.0 proposal. + +Note that `SDL_AppEvent` is only guaranteed to be called on the event thread for events raised by the window +manager/operating system. As such, we always assume that those events are on the event thread when received and invoke +the window directly. For other events, we should be wary of concurrency. Note that I have absolutely no idea what this +means for things like our `Surface.Continue` method for `IsEventDriven` - right now this isn't implemented. Read more +here: https://github.com/libsdl-org/SDL/issues/11387 diff --git a/docs/for-contributors/Windowing/README.md b/docs/for-contributors/Windowing/README.md new file mode 100644 index 0000000000..5e4c157be7 --- /dev/null +++ b/docs/for-contributors/Windowing/README.md @@ -0,0 +1,32 @@ +# Silk.NET.Windowing + +Silk.NET.Windowing is our cross-platform windowing abstraction. For more information about what it is, see the [proposal](../../proposals/Proposal%20-%20Windowing%203.0.md). + +As per the proposal, Windowing is implemented in exactly one project/assembly containing the abstractions and one +"reference implementation" given available target information (e.g. TFM). Today, this includes: +- SDL3, used for every platform. + +If the user doesn't want to use our reference implementation, it is expected that they use the trimmer to make its +presence benign. + +Note that for each "reference implementation" it is expected that there shall be a matching Silk.NET.Input "reference +implementation" capable of receiving an `INativeWindow` from the Silk.NET.Windowing implementation in use. How you +interpret this requirement is up to you, e.g. we could have a Silk.NET.Input Win32-specific implementation that uses +`Win32PlatformInfo` for our SDL3 surface, likewise we could have a Silk.NET.Input SDL3 implementation that receives a +`Win32PlatformInfo` from a Silk.NET.Windowing implementation and automatically creates a wrapping window - this is up to +you (but try to keep it sane please, that last one sounded extremely cursed). Ultimately, the goal is the user being +able to pull in `Silk.NET.Windowing` and `Silk.NET.Input`, create a surface, be able to do `surface.CreateInput()` and +it all Just Work. Right now, this equates to a 1:1 match of Silk.NET.Windowing/Silk.NET.Input implementations, and is +not expected to change. + +Silk.NET.Input is completely independent from Silk.NET.Windowing this time around, unlike 1.X/2.X. This is because we +believe the Input HLU can target wider applicability beyond just receiving input for a window, with VR being the +principal use case in mind when making this decision. For more information, read the [Multi-Backend Input proposal](../../proposals/Proposal%20-%20Multi-Backend%20Input.md). + +Most of the files within the top-level Windowing directory are exactly as proposed. The exception is the `Surface` +class, which seeks to make as much common as humanly possible (this includes the Render/Update timing logic and some +other auxiliary functions). Beyond that, this is functionally an interface. The actual entry-points into the Windowing +API, `ISurfaceApplication.Run` and `IDetachedSurfaceLifecycle.TryCreate`, are defined `partial`ly with matching +implementation parts in the `Implementations` subdirectories. + +To find out more about the implementation details, see the `Implementations` directory. diff --git a/docs/for-contributors/Windowing/future-improvements.md b/docs/for-contributors/Windowing/future-improvements.md new file mode 100644 index 0000000000..c08b209a14 --- /dev/null +++ b/docs/for-contributors/Windowing/future-improvements.md @@ -0,0 +1,87 @@ +# Future Improvements + +Initially when we were having design discussions around Silk.NET 3.0's Windowing API, we wanted to introduce a +lower-level API upon which our high-level API. The idea being that this would be an extensible API for which there would +be lower implementation friction and delegating common boilerplate code to a common higher-level implementation i.e. +there's very little work for us to do in mapping our API into new backends. This would functionally be a PAL, but the +details of this would depend on the actual requirements we derive as part of designing this API. Ultimately it was +determined that this work was simply out-of-scope for the initial 3.0 release as the extensibility benefits emerging +from having a lower-level API was determined to not be a requirement for the initial release, and was not included in +the original Working Group approved software development plan. + +We're well aware this sounds very similar to what our friends at OpenTK are planning for 5.0, for much of the same +reasons. Indeed we still have community members who are also OpenTK community members that were advocating for it for +this reason. It's great to consider this sort of prior art, the sharing of insights and lifting eachother up is what +makes open-source amazing after all. We should also consider how other libraries like SDL and GLFW handle this +internally. Much like OpenTK, there is motivation for adding a lower-level API to Silk.NET to reduce the implementation +friction in adding more windowing backends as we believe esoteric platforms like mobile could be served well by them. +Unlike OpenTK, for desktop there's less appetite due to the shear number of platforms that would cause a lot of +maintenance effort - OpenTK 4.0 moved to use GLFW because of this, and most of the issues logged before this were +regarding its per-platform custom implementations, whereas Silk.NET 3.0 is keen to optimise for maintainability and +delegating maintenance effort to more expert sources (as we have done for SilkTouch by using ClangSharp's P/Invoke +Generator) like SDL is part of this so we can focus on crafting the best user experience specific to our project. Hence +why even if we would add this lower-level API, unlike OpenTK 5.0 I don't think we'd use it to implement desktop +windowing ourselves. But that can change after the initial release, and in any case having this lower-level API would be +useful. + +When reviewing OpenTK specifically, their API design is indeed sound however the mechanisms by which it was exposed to +the higher-level API left a lot to be desired. Namely, using a dictionary of enums to implementations did not feel like +the best way to do this. There are likely more intelligent things we can do with the type system to make these patterns +more JIT friendly and also more extensible - having an enum enumerating the component types requires the extensibility +model to be defined in a way that is contrary to how the type system works e.g. to define components that are extensions +beyond our standard set. It was also deemed to be desirable to use `static abstract`s for this sort of low-level API, +which does help towards JIT friendliness, but this needn't prejudice any future efforts towards these goals - this was +just an idea. + +Ultimately, to make our solution more write-once-run-everywhere, the API design philosophy behind the `Surface` +type was primarily to make it seem like a modular "component bag" e.g. `window.OpenGL` for OpenGL-specific +functionality, rather than having specific APIs always exposed as part of the standard interface but only valid for +usage in specific circumstances. The `IView` separation in 2.X achieved what we wanted somewhat, but this again left a +lot to be desired given that writing against `IView` instead of `IWindow` is contrary to what most users were doing +(this is also likely a symptom of being an afterthought introduced quite late into the 1.0 Preview cycle). By using this +design philosophy, our users have to get used to not assuming that functionality is available, meaning that users are +encouraged to write in a way that is portable instead of them having to go out of their way by writing against `IView` +as in 1.X and 2.X. + +As for the extensibility goals (i.e. additional components being defined on top of our standard API), my hope was to +eventually have a `GetComponent` API on `Surface` which things like `window.OpenGL` were defined on top of. This has +been excluded from the 3.0 initial release, but we could in theory add something like this without the PAL concepts in +this document being implemented - a component-based architecture for our high-level API and a component-based +architecture for our low-level API can be developed independently. An example of why we might want this is a virtual +reality extension that manages the creation of OpenXR bindings from a surface, but this is just one example. It is +possible that "extension everything" might make this easier on the user while also making it easier for us (e.g. +extension everything defining an `window.OpenXR` property that implicitly checks the component can be created or +whatever, `DependentHandle` can probably used for this if we wanted or we could just use `window is IMyComponent` - +again these are all just ideas, this is just to demonstrate the idea of the API shape). Way earlier in 3.0's development +we were discussing the use of `IDynamicInterfaceCastable`, but the Silk.NET team were not able to implement support for +this in the Mono runtime in an acceptable timeframe and complexity level. All of these details depend on how and if we +make it possible to attach components to existing implementations without requiring modification of the original +backend. I would quite like this to be the case, but again it depends on the nature of the high-level component-based +architecture and/or the low-level component-based architecture i.e. where is the extensibility point. + +As much as we didn't continue down the path illustrated in this document, it was certainly explored somewhat before we +decided it wasn't needed for 3.0 (engineers like to overengineer, go figure). The first exploration was essentially a +static dependency injection API i.e. a [`IHluComponentRegistry`](https://github.com/dotnet/Silk.NET/blob/56af8e1b34dc41a43de10dff45d09d25f12e8e57/sources/Core/Core/Abstractions/IHluComponentRegistry.cs) +provides components (these can be changed together for extensibility) that configures a [`Surface`](https://github.com/dotnet/Silk.NET/blob/56af8e1b34dc41a43de10dff45d09d25f12e8e57/sources/Windowing/Common/Surface.cs) +(well, a [`IHluComponentHost`](https://github.com/dotnet/Silk.NET/blob/56af8e1b34dc41a43de10dff45d09d25f12e8e57/sources/Core/Core/Abstractions/IHluComponentHost.cs) +which `Surface` implements) with the components. There was also some [source generator magic](https://github.com/dotnet/Silk.NET/blob/56af8e1b34dc41a43de10dff45d09d25f12e8e57/sources/Core/Analyzers/HluSourceGenerator.Hosts.cs) +explored to make this more JIT friendly, but that itself had some downsides e.g. one object being an implementation type +of multiple component types had two references stored in the surface. These problems aren't insurmountable but +ultimately it was determined that making an entire dependency injection API just for this was a bit silly. + +After this attempt at implementing these concepts, another attempt was made that encompassed the low-level API desired +to reduce implementation friction. Essentially, [`ISurfaceHost`](https://github.com/dotnet/Silk.NET/blob/129d4957ce1058252723add2f6890fb53f234432/sources/Windowing/Common/Hosting/ISurfaceHost.cs) +had a bunch of lower-level APIs as `static abstract`s that essentially boiled down to "get a property, set a property" +on surface objects or surface requests. Didn't quite get round to implementing the "additional component" extensibility +concepts described but this could likely be done using type chaining and essentially changing those get/set property +methods to accept a generic "property type", but again these are just ideas - this was never realised or prototyped. +This was progressing well enough, and had some decent benefits as well like centralising all the [multi-threading logic](https://github.com/dotnet/Silk.NET/blob/129d4957ce1058252723add2f6890fb53f234432/sources/Windowing/Common/Hosting/MultiThreadedSurfaceHost%601.cs) +at the lowest level of implementation. + +All in all, there's a lot of benefits to having a modular, component-based, and extensible approach to designing our +windowing API and this is definitely something we're keen to pursue. But for now, we determined that for the 3.0 initial +release we only needed to do this for the user-facing API (as per the goals stated in the SDP to make the API more +encouraging of write-once-run-everywhere) and as much as we want to fulfill that `GetComponent` extensibility vision to +allow extensions of our standard API set, that also isn't needed for the initial release. Nonetheless, it was key to +ensure we had enough jumping off points to ensure this can be implemented in the future, and also to implement the +lower-level, implementation-facing API to make our life easier if we did want to add more backends outside of SDL. diff --git a/eng/silktouch/sdl/SDL3/generate.rsp b/eng/silktouch/sdl/SDL3/generate.rsp index 1503cdd39c..280ff68328 100644 --- a/eng/silktouch/sdl/SDL3/generate.rsp +++ b/eng/silktouch/sdl/SDL3/generate.rsp @@ -9,6 +9,9 @@ SDL_memmove SDL_memset SDL_BeginThreadFunction SDL_EndThreadFunction +SDL_fabsf +SDL_size_add_check_overflow_builtin +SDL_size_mul_check_overflow_builtin --file sdl-SDL.h --methodClassName @@ -32,6 +35,7 @@ Silk.NET.SDL ../../../submodules/sdl/include/SDL3/SDL_events.h ../../../submodules/sdl/include/SDL3/SDL_filesystem.h ../../../submodules/sdl/include/SDL3/SDL_gamepad.h +../../../submodules/sdl/include/SDL3/SDL_gpu.h ../../../submodules/sdl/include/SDL3/SDL_guid.h ../../../submodules/sdl/include/SDL3/SDL_haptic.h ../../../submodules/sdl/include/SDL3/SDL_hidapi.h @@ -45,6 +49,7 @@ Silk.NET.SDL ../../../submodules/sdl/include/SDL3/SDL_locale.h ../../../submodules/sdl/include/SDL3/SDL_log.h ../../../submodules/sdl/include/SDL3/SDL_messagebox.h +../../../submodules/sdl/include/SDL3/SDL_main.h ../../../submodules/sdl/include/SDL3/SDL_metal.h ../../../submodules/sdl/include/SDL3/SDL_misc.h ../../../submodules/sdl/include/SDL3/SDL_mouse.h @@ -53,11 +58,13 @@ Silk.NET.SDL ../../../submodules/sdl/include/SDL3/SDL_pixels.h ../../../submodules/sdl/include/SDL3/SDL_platform.h ../../../submodules/sdl/include/SDL3/SDL_power.h +../../../submodules/sdl/include/SDL3/SDL_process.h ../../../submodules/sdl/include/SDL3/SDL_properties.h ../../../submodules/sdl/include/SDL3/SDL_rect.h ../../../submodules/sdl/include/SDL3/SDL_render.h ../../../submodules/sdl/include/SDL3/SDL_scancode.h ../../../submodules/sdl/include/SDL3/SDL_sensor.h +../../../submodules/sdl/include/SDL3/SDL_stdinc.h ../../../submodules/sdl/include/SDL3/SDL_storage.h ../../../submodules/sdl/include/SDL3/SDL_surface.h ../../../submodules/sdl/include/SDL3/SDL_system.h @@ -67,3 +74,4 @@ Silk.NET.SDL ../../../submodules/sdl/include/SDL3/SDL_touch.h ../../../submodules/sdl/include/SDL3/SDL_version.h ../../../submodules/sdl/include/SDL3/SDL_video.h +../../../submodules/sdl/include/SDL3/SDL_vulkan.h diff --git a/eng/silktouch/sdl/SDL3/sdl-SDL.h b/eng/silktouch/sdl/SDL3/sdl-SDL.h index ba66a34371..cc79960371 100644 --- a/eng/silktouch/sdl/SDL3/sdl-SDL.h +++ b/eng/silktouch/sdl/SDL3/sdl-SDL.h @@ -1 +1,3 @@ #include +#include +#include diff --git a/eng/silktouch/sdl/remap.rsp b/eng/silktouch/sdl/remap.rsp index 8d06424c02..f1612ef540 100644 --- a/eng/silktouch/sdl/remap.rsp +++ b/eng/silktouch/sdl/remap.rsp @@ -1,2 +1,6 @@ --remap SDL_fabsf=float.Abs +VkSurfaceKHR=ulong +VkInstance=void* +VkPhysicalDevice=ulong +VkAllocationCallbacks=void diff --git a/eng/submodules/silk.net-2.x b/eng/submodules/silk.net-2.x index f34f8629b5..ca36450946 160000 --- a/eng/submodules/silk.net-2.x +++ b/eng/submodules/silk.net-2.x @@ -1 +1 @@ -Subproject commit f34f8629b57f43f12cd4d7d559623f51738ca99b +Subproject commit ca364509467f0fb40af40f7ed040b4c63670a4c6 diff --git a/global.json b/global.json new file mode 100644 index 0000000000..2b63e6f386 --- /dev/null +++ b/global.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "9.0.100", + "rollForward": "major" + } +} \ No newline at end of file diff --git a/sources/Core/Core/Abstractions/AndroidPlatformInfo.cs b/sources/Core/Core/Abstractions/AndroidPlatformInfo.cs new file mode 100644 index 0000000000..621cde83e7 --- /dev/null +++ b/sources/Core/Core/Abstractions/AndroidPlatformInfo.cs @@ -0,0 +1,8 @@ +namespace Silk.NET.Core; + +/// +/// The Android platform-specific handles. +/// +/// ANativeWindow*. +/// EGLSurface. +public readonly record struct AndroidPlatformInfo(nint Window, nint Surface); diff --git a/sources/Core/Core/Abstractions/BreakneckLock.cs b/sources/Core/Core/Abstractions/BreakneckLock.cs new file mode 100644 index 0000000000..588b2d3576 --- /dev/null +++ b/sources/Core/Core/Abstractions/BreakneckLock.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. + +// Sourced from https://github.com/john-h-k/SpinLockSlim under the MIT license + +// MIT License +// +// Copyright (c) 2019 John Kelly +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +// ReSharper disable RedundantAssignment + +namespace Silk.NET.Core; + +/// +/// Provided a lightweight spin lock for synchronization in high performance +/// scenarios with a low hold time +/// +/// +/// This lock is very performant, but it is very dangerous (hence breakneck). +/// It's recommended to use the framework-provided locks where possible. +/// +public struct BreakneckLock +{ + private static int True => 1; + private static int False => 0; + + private const MethodImplOptions MaxOpt = (MethodImplOptions)768; + + private volatile int _acquired; // either 1 or 0 + + /// + /// Creates a new + /// + /// A new + [MethodImpl(MaxOpt)] + public static BreakneckLock Create() => new(); + + /// + /// Returns true if the lock is acquired, else false + /// +#pragma warning disable 420 // Unsafe.As<,> doesn't read the reference so the lack of volatility is not an issue, but we do need to treat the returned reference as volatile + public bool IsAcquired => Volatile.Read(ref Unsafe.As(ref _acquired)); +#pragma warning restore 420 + + /// + /// Enter the lock. If this method returns, + /// will be true. If an exception occurs, will indicate + /// whether the lock was taken and needs to be released using . + /// This method may never exit + /// + /// A reference to a bool that indicates whether the lock is taken. Must + /// be false when passed, else the internal state or return state may be corrupted. + /// If the method returns, this is guaranteed to be true + [MethodImpl(MaxOpt)] + public void Enter(ref bool taken) + { + // while acquired == 1, loop, then when it == 0, exit and set it to 1 + while (!TryAcquire()) + { + // NOP + } + + taken = true; + } + + /// + /// Enter the lock if it not acquired, else, do not. will be + /// true if the lock was taken, else false. If is + /// true, must be called to release it, else, it must not be called + /// + /// A reference to a bool that indicates whether the lock is taken. Must + /// be false when passed, else the internal state or return state may be corrupted + [MethodImpl(MaxOpt)] + public void TryEnter(ref bool taken) + { + taken = TryAcquire(); + } + + /// + /// Try to safely enter the lock a certain number of times (). + /// will be true if the lock was taken, else false. + /// If is true, must be called to release + /// it, else, it must not be called + /// + /// A reference to a bool that indicates whether the lock is taken. Must + /// be false when passed, else the internal state or return state may be corrupted + /// The number of attempts to acquire the lock before returning + /// without the lock + [MethodImpl(MaxOpt)] + public void TryEnter(ref bool taken, uint iterations) + { + // if it acquired == 0, change it to 1 and return true, else return false + while (!TryAcquire()) + { + if (unchecked(iterations--) == 0) // postfix decrement, so no issue if iterations == 0 at first + { + return; + } + } + + taken = true; + } + + /// + /// Try to safely enter the lock for a certain (). + /// will be true if the lock was taken, else false. + /// If is true, must be called to release + /// it, else, it must not be called + /// + /// A reference to a bool that indicates whether the lock is taken. Must + /// be false when passed, else the internal state or return state may be corrupted + /// The to attempt to acquire the lock for before + /// returning without the lock. A negative will cause undefined behaviour + [MethodImpl(MaxOpt)] + public void TryEnter(ref bool taken, TimeSpan timeout) + { + long start = Stopwatch.GetTimestamp(); + long end = unchecked((long)timeout.TotalMilliseconds * Stopwatch.Frequency + start); + + // if it acquired == 0, change it to 1 and return true, else return false + while (!TryAcquire()) + { + if (Stopwatch.GetTimestamp() >= end) + { + return; + } + } + + taken = true; + } + + /// + /// Exit the lock. This method is dangerous and must be called only once the caller is sure they have + /// ownership of the lock. + /// + [MethodImpl(MaxOpt)] + public void Exit() + { + // release the lock - int32 write will always be atomic + _acquired = False; + } + + /// + /// Exit the lock with an optional post-release memory barrier. This method is dangerous and must be called only + /// once the caller is sure they have ownership of the lock. + /// + /// Whether a memory barrier should be inserted after the release + [MethodImpl(MaxOpt)] + public void Exit(bool insertMemBarrier) + { + Exit(); + + if (insertMemBarrier) + Thread.MemoryBarrier(); + } + + /// + /// Exit the lock with a post-release memory barrier. This method is dangerous and must be called only once the + /// caller is sure they have ownership of the lock. + /// + [MethodImpl(MaxOpt)] + public void ExitWithBarrier() + { + Exit(); + Thread.MemoryBarrier(); + } + + [MethodImpl(MaxOpt)] + private bool TryAcquire() + { + // if it acquired == 0, change it to 1 and return true, else return false + return Interlocked.CompareExchange(ref _acquired, True, False) == False; + } +} diff --git a/sources/Core/Core/Abstractions/BreakneckRequest`1.cs b/sources/Core/Core/Abstractions/BreakneckRequest`1.cs new file mode 100644 index 0000000000..9f4c77d0b7 --- /dev/null +++ b/sources/Core/Core/Abstractions/BreakneckRequest`1.cs @@ -0,0 +1,64 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Core; + +/// +/// Provides a lightweight mechanism for requesting a resource from a producer thread and spinning until the request is +/// fulfilled. +/// +/// +/// This struct is very performant, but it is very dangerous (hence breakneck). +/// It's recommended to use the framework-provided locks where possible. +/// +/// The resource to request. +public struct BreakneckRequest +{ + private int _currentSerial; + private int _requestedSerial; + private int _gate; + private TResource _result; + + /// + /// Used by the producing thread only to determine whether the resource is requested. + /// + public bool IsRequested => _requestedSerial != _currentSerial; + + /// + /// Requests the resource. + /// + /// The resource. + public TResource Request() + { + // 1. Get a ticket - we use Interlocked here because there are potentially many threads doing the same. + var ourTicket = Interlocked.Increment(ref _requestedSerial); + + // 2. Wait in line. + while (Interlocked.CompareExchange(ref _currentSerial, ourTicket, ourTicket) != ourTicket) + { } + + // 5. Get the result. + var ret = _result; + _result = default!; + Interlocked.Decrement(ref _gate); // 0 = "I have picked up my things" + return ret; + } + + /// + /// Provides the resource requested. + /// + /// The resource. + /// + /// This must only be called once it is validated that is true. Failure to follow + /// this will result in this function hanging forever. + /// + public void Provide(TResource resource) + { + // 3. Wait for the last requester in line to pick up their things. + while (Interlocked.CompareExchange(ref _gate, 1, 0) != 0) { } + + // 4. Serve the next ticket. + _result = resource; + Interlocked.Increment(ref _currentSerial); + } +} diff --git a/sources/Core/Core/Abstractions/BreakneckRequest`2.cs b/sources/Core/Core/Abstractions/BreakneckRequest`2.cs new file mode 100644 index 0000000000..fa33e7ebff --- /dev/null +++ b/sources/Core/Core/Abstractions/BreakneckRequest`2.cs @@ -0,0 +1,92 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; + +namespace Silk.NET.Core; + +/// +/// Provides a lightweight mechanism for requesting a resource with request data from a producer thread and spinning +/// until the request is fulfilled. +/// +/// +/// This struct is very performant, but it is very dangerous (hence breakneck). +/// It's recommended to use the framework-provided locks where possible. +/// +/// The resource to request. +/// The parameters of the request. +public struct BreakneckRequest +{ + private int _currentSerial; + private int _requestedSerial; + private int _gate; + private TParameters _params; + private TResource _result; + + /// + /// Requests the resource. + /// + /// The resource. + public TResource Request(TParameters parameters) + { + // 1. Get a ticket - we use Interlocked here because there are potentially many threads doing the same. + var ourTicket = Interlocked.Increment(ref _requestedSerial); + + // 2. Wait in line. + while (Interlocked.CompareExchange(ref _currentSerial, ourTicket, ourTicket) != ourTicket) + { } + + // 6. Provide our parameters + _params = parameters; + Interlocked.Decrement(ref _gate); // 2 = "I have sent my parameters" + + // 9. Wait for the provider to give us the resource. + while (_gate != 1) { } + + // 10. Get the result. + var ret = _result; + _result = default!; + Interlocked.Decrement(ref _gate); // 0 = "I have picked up my things" + return ret; + } + + /// + /// Attempts to retrieve a request. + /// + /// The request parameters. + /// True if a request was found, false otherwise. + /// + /// must be called if this function returns true. + /// + public bool TryGetRequest([NotNullWhen(true)] out TParameters? parameters) + { + // 3. Determine whether we have a request to serve + if (_requestedSerial == _currentSerial) + { + parameters = default; + return false; + } + + // 4. Wait for the last requester in line to pick up their things. + while (Interlocked.CompareExchange(ref _gate, 3, 0) != 0) { } + + // 5. Serve the next ticket. + Interlocked.Increment(ref _currentSerial); + + // 7. Wait for the requester to give us their parameters. + while (_gate != 2) { } + parameters = _params!; + return true; + } + + /// + /// Provides the resource requested. + /// + /// The resource. + public void Provide(TResource resource) + { + // 8. Provide the result. + _result = resource; + Interlocked.Decrement(ref _gate); // 1 = "I now have the resource" + } +} diff --git a/sources/Core/Core/Abstractions/CocoaPlatformInfo.cs b/sources/Core/Core/Abstractions/CocoaPlatformInfo.cs new file mode 100644 index 0000000000..4ead42b322 --- /dev/null +++ b/sources/Core/Core/Abstractions/CocoaPlatformInfo.cs @@ -0,0 +1,7 @@ +namespace Silk.NET.Core; + +/// +/// The Cocoa platform-specific handles. +/// +/// NSWindow. +public readonly record struct CocoaPlatformInfo(nint Window); diff --git a/sources/Core/Core/Abstractions/EGLPlatformInfo.cs b/sources/Core/Core/Abstractions/EGLPlatformInfo.cs new file mode 100644 index 0000000000..04308d3d9f --- /dev/null +++ b/sources/Core/Core/Abstractions/EGLPlatformInfo.cs @@ -0,0 +1,8 @@ +namespace Silk.NET.Core; + +/// +/// The EGL platform-specific handles. +/// +/// EGLDisplay. +/// EGLSurface. +public readonly record struct EGLPlatformInfo(nint Display, nint Surface); diff --git a/sources/Core/Core/Abstractions/IGLContext.cs b/sources/Core/Core/Abstractions/IGLContext.cs index 6063c41a36..128e6c18ba 100644 --- a/sources/Core/Core/Abstractions/IGLContext.cs +++ b/sources/Core/Core/Abstractions/IGLContext.cs @@ -5,34 +5,29 @@ namespace Silk.NET.Core; /// /// Represents an OpenGL context. /// -public interface IGLContext : INativeContext, IDisposable +public interface IGLContext : INativeContext { /// /// Whether the context is current on this thread. /// - bool IsCurrent { get; } + bool IsCurrent { get; set; } /// - /// Sets the number of vertical blanks to wait for until the next backbuffer swap. + /// The number of vertical blanks to wait for before sending another frame. /// - /// The number of frames. - void SwapInterval(int interval); + int SwapInterval { get; set; } /// - /// Swaps the backbuffer to present the contents to the window. + /// Gets or sets a value indicating whether is non-zero. /// - void SwapBuffers(); + bool VSync + { + get => SwapInterval > 0; + set => SwapInterval = value ? 1 : 0; + } /// - /// Makes the context current. - /// - void MakeCurrent(); - - /// - /// Clears the context from this thread. + /// Swaps the backbuffer to present the contents to the window. /// - /// - /// This should check whether GL.ThisThread has this as current as well. - /// - void Clear(); + void SwapBuffers(); } diff --git a/sources/Core/Core/Abstractions/IGLContextSource.cs b/sources/Core/Core/Abstractions/IGLContextSource.cs new file mode 100644 index 0000000000..1e7b6c05ac --- /dev/null +++ b/sources/Core/Core/Abstractions/IGLContextSource.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Core; + +/// +/// Represents a source of a +/// +// Same as in 1.X/2.X, just a different namespace. +public interface IGLContextSource +{ + /// + /// The OpenGL context. + /// + IGLContext? GLContext { get; } +} diff --git a/sources/Core/Core/Abstractions/INativeWindow.cs b/sources/Core/Core/Abstractions/INativeWindow.cs new file mode 100644 index 0000000000..432add7f3c --- /dev/null +++ b/sources/Core/Core/Abstractions/INativeWindow.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; + +namespace Silk.NET.Core; + +/// +/// Represents a window that possesses native handles or other platform-specific information. +/// +public interface INativeWindow +{ + /// + /// Attempts to obtain native platform information with type . + /// + /// + /// The platform-specific information, or default if the platform-specific information is not available for + /// this platform. + /// + /// True if contains the platform-specific information, false otherwise. + bool TryGetPlatformInfo([NotNullWhen(true)] out TPlatformInfo? info); +} diff --git a/sources/Core/Core/Abstractions/UIKitPlatformInfo.cs b/sources/Core/Core/Abstractions/UIKitPlatformInfo.cs new file mode 100644 index 0000000000..468673f1f7 --- /dev/null +++ b/sources/Core/Core/Abstractions/UIKitPlatformInfo.cs @@ -0,0 +1,15 @@ +namespace Silk.NET.Core; + +/// +/// The UIKit platform-specific handles. +/// +/// UIWindow. +/// OpenGL framebuffer handle. +/// OpenGL color buffer handle. +/// OpenGL resolve framebuffer handle. +public readonly record struct UIKitPlatformInfo( + nint Window, + uint Framebuffer, + uint ColorBuffer, + uint ResolveFramebuffer +); diff --git a/sources/Core/Core/Abstractions/Version32.cs b/sources/Core/Core/Abstractions/Version32.cs new file mode 100644 index 0000000000..d825d8aba7 --- /dev/null +++ b/sources/Core/Core/Abstractions/Version32.cs @@ -0,0 +1,81 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Core; + +/// +/// A 32-bit version structure. +/// +public readonly struct Version32 +{ + /// + /// The underlying Vulkan-compatible 32-bit version integer. + /// + public uint Value { get; } + + /// + /// Creates a Vulkan version structure from the given major, minor, and patch values. + /// + /// The major value. + /// The minor value. + /// The patch value. + /// The variant value. + public Version32(uint major, uint minor, uint patch = 0, uint variant = 0) => + Value = (variant << 29) | (major << 22) | (minor << 12) | patch; + + /// + /// Creates a Vulkan version structure from the given Vulkan-compatible value. + /// + /// The value. + private Version32(uint value) => Value = value; + + /// + /// Gets the major component of this version structure. + /// + public uint Major => (Value >> 22) & 0x7f; + + /// + /// Gets the minor component of this version structure. + /// + public uint Minor => (Value >> 12) & 0x3ff; + + /// + /// Gets the patch component of this version structure. + /// + public uint Patch => Value & 0xfff; + + /// + /// Gets the variant component of this version structure. + /// + public uint Variant => Value >> 29; + + /// + /// Creates a 32-bit version structure from the given 32-bit unsigned integer. + /// + /// The uint value. + /// The 32-bit version structure. + public static explicit operator Version32(uint val) => new(val); + + /// + /// Creates a 32-bit version structure from the given managed version class. + /// + /// The version instance. + /// The 32-bit version structure. + public static implicit operator Version32(Version version) => + new((uint)version.Major, (uint)version.Minor, (uint)version.Build); + + /// + /// Gets the 32-bit unsigned integer representation for this 32-bit version structure. + /// + /// The 32-bit version structure. + /// The 32-bit unsigned integer. + public static implicit operator uint(Version32 version) => version.Value; + + /// + /// Converts this 32-bit version structure to a managed version class. + /// + /// The 32-bit version structure. + /// The managed representation. + public static implicit operator Version(Version32 version) => + new((int)version.Major, (int)version.Minor, (int)version.Patch); +} diff --git a/sources/Core/Core/Abstractions/VivantePlatformInfo.cs b/sources/Core/Core/Abstractions/VivantePlatformInfo.cs new file mode 100644 index 0000000000..25a02093f5 --- /dev/null +++ b/sources/Core/Core/Abstractions/VivantePlatformInfo.cs @@ -0,0 +1,8 @@ +namespace Silk.NET.Core; + +/// +/// The Vivante platform-specific handles. +/// +/// EGLNativeDisplayType. +/// EGLNativeWindowType. +public readonly record struct VivantePlatformInfo(nint Display, nint Window); diff --git a/sources/Core/Core/Abstractions/WaylandPlatformInfo.cs b/sources/Core/Core/Abstractions/WaylandPlatformInfo.cs new file mode 100644 index 0000000000..3dfa5a67d1 --- /dev/null +++ b/sources/Core/Core/Abstractions/WaylandPlatformInfo.cs @@ -0,0 +1,8 @@ +namespace Silk.NET.Core; + +/// +/// The Wayland platform-specific handles. +/// +/// wl_display. +/// wl_surface. +public readonly record struct WaylandPlatformInfo(nint Display, nint Surface); diff --git a/sources/Core/Core/Abstractions/Win32PlatformInfo.cs b/sources/Core/Core/Abstractions/Win32PlatformInfo.cs new file mode 100644 index 0000000000..374c5bdc95 --- /dev/null +++ b/sources/Core/Core/Abstractions/Win32PlatformInfo.cs @@ -0,0 +1,9 @@ +namespace Silk.NET.Core; + +/// +/// The Win32 platform-specific handles. +/// +/// HWND. +/// HDC. +/// HInstance. +public readonly record struct Win32PlatformInfo(nint Hwnd, nint HDC, nint HInstance); diff --git a/sources/Core/Core/Abstractions/WinRTPlatformInfo.cs b/sources/Core/Core/Abstractions/WinRTPlatformInfo.cs new file mode 100644 index 0000000000..58ccb7a95e --- /dev/null +++ b/sources/Core/Core/Abstractions/WinRTPlatformInfo.cs @@ -0,0 +1,7 @@ +namespace Silk.NET.Core; + +/// +/// The WinRT platform-specific handles. +/// +/// IInspectable. +public readonly record struct WinRTPlatformInfo(nint Inspectable); diff --git a/sources/Core/Core/Abstractions/X11PlatformInfo.cs b/sources/Core/Core/Abstractions/X11PlatformInfo.cs new file mode 100644 index 0000000000..2aba92d219 --- /dev/null +++ b/sources/Core/Core/Abstractions/X11PlatformInfo.cs @@ -0,0 +1,8 @@ +namespace Silk.NET.Core; + +/// +/// The X11 platform-specific handles. +/// +/// X11Display. +/// X11Window. +public readonly record struct X11PlatformInfo(nint Display, nint Window); diff --git a/sources/Core/Core/DSL/Default.cs b/sources/Core/Core/DSL/Default.cs index bfa1ab2a0a..2e3ace774d 100644 --- a/sources/Core/Core/DSL/Default.cs +++ b/sources/Core/Core/DSL/Default.cs @@ -1,17 +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.Diagnostics.CodeAnalysis; using System.Numerics; using System.Runtime.CompilerServices; namespace Silk.NET.Core; /// -/// The "default" option for variance of DSL types using type parameters. For example, use this in place of a -/// type parameter to use the default boolean scheme (as implemented by +/// The "default" option for variance of DSL types using type parameters. +/// +/// +/// +/// Use this in place of a type parameter to use the default boolean scheme (as implemented by /// ) +/// +/// +/// +/// +/// /// -public class Default : IBoolScheme +public struct Default : IBoolScheme { /// [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] diff --git a/sources/Core/Core/Pointers/Ptr.cs b/sources/Core/Core/Pointers/Ptr.cs index a858aa2fd5..4f6a0e2710 100644 --- a/sources/Core/Core/Pointers/Ptr.cs +++ b/sources/Core/Core/Pointers/Ptr.cs @@ -102,6 +102,7 @@ public T[] ToArray(int length) [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] + // TODO analyzer to ensure ptr is on stack or otherwise pinned public static bool operator ==(Ref lh, Ptr rh) => (void*)lh == rh.Native; /// @@ -257,6 +258,20 @@ public T[] ToArray(int length) )] public static explicit operator string(Ptr ptr) => ptr.ReadToString(); + /// + /// Casts the underlying pointer to a native-sized integer. + /// + /// The pointer. + /// The integer. + public static explicit operator nint(Ptr ptr) => (nint)(void*)ptr; + + /// + /// Interprets the given native-sized integer as a pointer. + /// + /// The integer. + /// The pointer. + public static explicit operator Ptr(nint ptr) => (void*)ptr; + /// /// Creates a null ptr /// diff --git a/sources/Core/Core/Pointers/Ptr.generic.cs b/sources/Core/Core/Pointers/Ptr.generic.cs index 39ae702ce0..8a925b9837 100644 --- a/sources/Core/Core/Pointers/Ptr.generic.cs +++ b/sources/Core/Core/Pointers/Ptr.generic.cs @@ -327,6 +327,7 @@ public unsafe struct Ptr(T* ptr) [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] + // TODO analyzer to ensure ptr is on stack or otherwise pinned public static explicit operator Ptr(Ref ptr) => (T*)ptr; /// @@ -338,6 +339,15 @@ public unsafe struct Ptr(T* ptr) )] public static implicit operator Ptr(Ptr ptr) => new Ptr(ptr.Native); + /// + /// Creates a from a + /// + /// + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ref(Ptr ptr) => ptr.Native; + /// /// Creates a from a /// diff --git a/sources/Core/Core/Pointers/Ptr2D.cs b/sources/Core/Core/Pointers/Ptr2D.cs index 50bcae2657..679817b472 100644 --- a/sources/Core/Core/Pointers/Ptr2D.cs +++ b/sources/Core/Core/Pointers/Ptr2D.cs @@ -353,8 +353,33 @@ public T[][] ToArray(int length, int[] lengths) [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] + // TODO analyzer to ensure ptr is on stack or otherwise pinned public static explicit operator Ptr2D(Ref2D ptr) => (void**)ptr; + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ref(Ptr2D ptr) => ptr.Native; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ptr(Ptr2D ptr) => ptr.Native; + /// /// Creates a null ptr /// diff --git a/sources/Core/Core/Pointers/Ptr2D.generic.cs b/sources/Core/Core/Pointers/Ptr2D.generic.cs index c9ea41d00e..3b7fc47c85 100644 --- a/sources/Core/Core/Pointers/Ptr2D.generic.cs +++ b/sources/Core/Core/Pointers/Ptr2D.generic.cs @@ -515,7 +515,8 @@ public T[][] ToArray(int length, int[] lengths) => [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static implicit operator Ptr2D(Ref2D ptr) => (void**)ptr; + // TODO analyzer to ensure ptr is on stack or otherwise pinned + public static explicit operator Ptr2D(Ref2D ptr) => (void**)ptr; /// /// Creates a from a @@ -524,7 +525,32 @@ public T[][] ToArray(int length, int[] lengths) => [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static implicit operator Ptr2D(Ref2D ptr) => (T**)ptr; + // TODO analyzer to ensure ptr is on stack or otherwise pinned + public static explicit operator Ptr2D(Ref2D ptr) => (T**)ptr; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ref(Ptr2D ptr) => ptr.Native; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ptr(Ptr2D ptr) => ptr.Native; /// /// Creates a from a diff --git a/sources/Core/Core/Pointers/Ptr3D.cs b/sources/Core/Core/Pointers/Ptr3D.cs index 96fa9121d9..8f5e994f98 100644 --- a/sources/Core/Core/Pointers/Ptr3D.cs +++ b/sources/Core/Core/Pointers/Ptr3D.cs @@ -370,13 +370,37 @@ ptr.Native is not null && ptr.Native->Native is not null public static implicit operator void***(Ptr3D ptr) => (void***)ptr.Native; /// - /// Creates a from a + /// Creates a from a /// /// [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static implicit operator Ref2D(Ptr3D ptr) => ptr.Native; + public static implicit operator Ref3D(Ptr3D ptr) => ptr.Native; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ref(Ptr3D ptr) => ptr.Native; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ptr(Ptr3D ptr) => ptr.Native; /// /// Creates a from a @@ -385,6 +409,7 @@ ptr.Native is not null && ptr.Native->Native is not null [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] + // TODO analyzer to ensure ptr is on stack or otherwise pinned public static explicit operator Ptr3D(Ref2D ptr) => (void**)ptr; /// diff --git a/sources/Core/Core/Pointers/Ptr3D.generic.cs b/sources/Core/Core/Pointers/Ptr3D.generic.cs index d14c9b9bc3..bb11492c71 100644 --- a/sources/Core/Core/Pointers/Ptr3D.generic.cs +++ b/sources/Core/Core/Pointers/Ptr3D.generic.cs @@ -534,6 +534,30 @@ ptr.Native is not null && ptr.Native->Native is not null )] public static implicit operator Ref3D(Ptr3D ptr) => ptr.Native; + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ref(Ptr3D ptr) => ptr.Native; + + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static implicit operator Ptr(Ptr3D ptr) => ptr.Native; + /// /// Creates a from a /// @@ -541,7 +565,8 @@ ptr.Native is not null && ptr.Native->Native is not null [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static implicit operator Ptr3D(Ref3D ptr) => (void***)ptr; + // TODO analyzer to ensure ptr is on stack or otherwise pinned + public static explicit operator Ptr3D(Ref3D ptr) => (void***)ptr; /// /// Creates a from a @@ -550,7 +575,8 @@ ptr.Native is not null && ptr.Native->Native is not null [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static implicit operator Ptr3D(Ref3D ptr) => (T***)ptr; + // TODO analyzer to ensure ptr is on stack or otherwise pinned + public static explicit operator Ptr3D(Ref3D ptr) => (T***)ptr; /// /// Creates a from a diff --git a/sources/Core/Core/Pointers/Ref.generic.cs b/sources/Core/Core/Pointers/Ref.generic.cs index c94bc40361..affa362cdd 100644 --- a/sources/Core/Core/Pointers/Ref.generic.cs +++ b/sources/Core/Core/Pointers/Ref.generic.cs @@ -143,7 +143,7 @@ public ref T this[nuint index] /// /// The span to create the ref from. [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - // TODO const correctness analyzers + // TODO annotate requires readonly dest - const correctness etc public static implicit operator Ref(ReadOnlySpan span) => new(ref Unsafe.AsRef(in span.GetPinnableReference())); @@ -244,11 +244,15 @@ public static unsafe explicit operator string(Ref ptr) /// Creates a from a string /// /// - public static implicit operator Ref(string str) + public static implicit operator Ref(string? str) { if (typeof(T) == typeof(char) || typeof(T) == typeof(ushort) || typeof(T) == typeof(short)) { - return new(ref Unsafe.As(ref Unsafe.AsRef(in str.GetPinnableReference()))); + return str is not null + ? new Ref( + ref Unsafe.As(ref Unsafe.AsRef(in str.GetPinnableReference())) + ) + : nullptr; } if (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte)) diff --git a/sources/Core/Core/Pointers/Ref2D.cs b/sources/Core/Core/Pointers/Ref2D.cs index 608224d624..21243f2058 100644 --- a/sources/Core/Core/Pointers/Ref2D.cs +++ b/sources/Core/Core/Pointers/Ref2D.cs @@ -210,6 +210,16 @@ public ref Ref this[nuint index] public static implicit operator Ref2D(byte[][] array) => SilkMarshal.JaggedArrayToPointerArray(array); + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static implicit operator Ref(Ref2D ptr) => new(ref ptr.InteriorRef); + /// /// creates a from a reference array /// diff --git a/sources/Core/Core/Pointers/Ref2D.generic.cs b/sources/Core/Core/Pointers/Ref2D.generic.cs index afab9b96d0..448bea5192 100644 --- a/sources/Core/Core/Pointers/Ref2D.generic.cs +++ b/sources/Core/Core/Pointers/Ref2D.generic.cs @@ -238,6 +238,16 @@ public ref Ref this[nuint index] public static implicit operator Ref2D(T[][] array) => SilkMarshal.JaggedArrayToPointerArray(array); + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static implicit operator Ref(Ref2D ptr) => new(ref ptr.InteriorRef); + /// /// creates a from a reference array /// @@ -270,6 +280,6 @@ public static implicit operator Ref2D(T*[] array) /// /// The string array. /// The - public static implicit operator Ref2D(string[] array) => + public static implicit operator Ref2D(string?[] array) => new(ref SilkMarshal.StringArrayToNative(array, sizeof(T))); } diff --git a/sources/Core/Core/Pointers/Ref3D.cs b/sources/Core/Core/Pointers/Ref3D.cs index c5d8e00273..a8b7afff6c 100644 --- a/sources/Core/Core/Pointers/Ref3D.cs +++ b/sources/Core/Core/Pointers/Ref3D.cs @@ -210,6 +210,16 @@ public ref Ref2D this[nuint index] public static implicit operator Ref3D(byte[][][] array) => SilkMarshal.JaggedArrayToPointerArray(array); + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static implicit operator Ref(Ref3D ptr) => new(ref ptr.InteriorRef); + /// /// creates a from a reference array /// diff --git a/sources/Core/Core/Pointers/Ref3D.generic.cs b/sources/Core/Core/Pointers/Ref3D.generic.cs index 23bbc5d090..e0016e1997 100644 --- a/sources/Core/Core/Pointers/Ref3D.generic.cs +++ b/sources/Core/Core/Pointers/Ref3D.generic.cs @@ -239,6 +239,16 @@ public ref Ref2D this[nuint index] public static implicit operator Ref3D(T[][][] array) => SilkMarshal.JaggedArrayToPointerArray(array); + /// + /// Expresses this as a . Note that this does not index the + /// 's dimensions, and is effectively equivalent to converting a void*** to a + /// void*. + /// + /// The . + /// The . + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static implicit operator Ref(Ref3D ptr) => new(ref ptr.InteriorRef); + /// /// creates a from a reference array /// @@ -271,6 +281,6 @@ public static implicit operator Ref3D(T**[] array) /// /// The string array. /// The - public static implicit operator Ref3D(string[][] array) => + public static implicit operator Ref3D(string?[][] array) => new(ref SilkMarshal.StringArrayToNative(array, sizeof(T))); } diff --git a/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 1a0591f204..14eb48880a 100644 --- a/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -32,6 +32,38 @@ readonly Silk.NET.Core.Ptr3D.Native -> Silk.NET.Core.Ptr2D* readonly Silk.NET.Core.Ptr.Native -> T* readonly Silk.NET.Core.Ref.Handle -> byte readonly Silk.NET.Core.Ref.Handle -> T +Silk.NET.Core.AndroidPlatformInfo +Silk.NET.Core.AndroidPlatformInfo.AndroidPlatformInfo() -> void +Silk.NET.Core.AndroidPlatformInfo.AndroidPlatformInfo(nint Window, nint Surface) -> void +Silk.NET.Core.AndroidPlatformInfo.Surface.get -> nint +Silk.NET.Core.AndroidPlatformInfo.Surface.init -> void +Silk.NET.Core.AndroidPlatformInfo.Window.get -> nint +Silk.NET.Core.AndroidPlatformInfo.Window.init -> void +Silk.NET.Core.BreakneckLock +Silk.NET.Core.BreakneckLock.BreakneckLock() -> void +Silk.NET.Core.BreakneckLock.Enter(ref bool taken) -> void +Silk.NET.Core.BreakneckLock.Exit() -> void +Silk.NET.Core.BreakneckLock.Exit(bool insertMemBarrier) -> void +Silk.NET.Core.BreakneckLock.ExitWithBarrier() -> void +Silk.NET.Core.BreakneckLock.IsAcquired.get -> bool +Silk.NET.Core.BreakneckLock.TryEnter(ref bool taken) -> void +Silk.NET.Core.BreakneckLock.TryEnter(ref bool taken, System.TimeSpan timeout) -> void +Silk.NET.Core.BreakneckLock.TryEnter(ref bool taken, uint iterations) -> void +Silk.NET.Core.BreakneckRequest +Silk.NET.Core.BreakneckRequest.BreakneckRequest() -> void +Silk.NET.Core.BreakneckRequest.Provide(TResource resource) -> void +Silk.NET.Core.BreakneckRequest.Request(TParameters parameters) -> TResource +Silk.NET.Core.BreakneckRequest.TryGetRequest(out TParameters? parameters) -> bool +Silk.NET.Core.BreakneckRequest +Silk.NET.Core.BreakneckRequest.BreakneckRequest() -> void +Silk.NET.Core.BreakneckRequest.IsRequested.get -> bool +Silk.NET.Core.BreakneckRequest.Provide(TResource resource) -> void +Silk.NET.Core.BreakneckRequest.Request() -> TResource +Silk.NET.Core.CocoaPlatformInfo +Silk.NET.Core.CocoaPlatformInfo.CocoaPlatformInfo() -> void +Silk.NET.Core.CocoaPlatformInfo.CocoaPlatformInfo(nint Window) -> void +Silk.NET.Core.CocoaPlatformInfo.Window.get -> nint +Silk.NET.Core.CocoaPlatformInfo.Window.init -> void Silk.NET.Core.Constant Silk.NET.Core.Constant.Constant() -> void Silk.NET.Core.Constant.Constant(TUnderlying Value) -> void @@ -48,16 +80,29 @@ Silk.NET.Core.CppAttributeListAttribute.CppAttributeListAttribute(string! attrib Silk.NET.Core.Default Silk.NET.Core.Default.Default() -> void Silk.NET.Core.DSL +Silk.NET.Core.EGLPlatformInfo +Silk.NET.Core.EGLPlatformInfo.Display.get -> nint +Silk.NET.Core.EGLPlatformInfo.Display.init -> void +Silk.NET.Core.EGLPlatformInfo.EGLPlatformInfo() -> void +Silk.NET.Core.EGLPlatformInfo.EGLPlatformInfo(nint Display, nint Surface) -> void +Silk.NET.Core.EGLPlatformInfo.Surface.get -> nint +Silk.NET.Core.EGLPlatformInfo.Surface.init -> void Silk.NET.Core.IBoolScheme Silk.NET.Core.IBoolScheme.False() -> T Silk.NET.Core.IBoolScheme.IsTrue(T value) -> bool Silk.NET.Core.IBoolScheme.True() -> T Silk.NET.Core.IGLContext -Silk.NET.Core.IGLContext.Clear() -> void Silk.NET.Core.IGLContext.IsCurrent.get -> bool -Silk.NET.Core.IGLContext.MakeCurrent() -> void +Silk.NET.Core.IGLContext.IsCurrent.set -> void Silk.NET.Core.IGLContext.SwapBuffers() -> void -Silk.NET.Core.IGLContext.SwapInterval(int interval) -> void +Silk.NET.Core.IGLContext.SwapInterval.get -> int +Silk.NET.Core.IGLContext.SwapInterval.set -> void +Silk.NET.Core.IGLContext.VSync.get -> bool +Silk.NET.Core.IGLContext.VSync.set -> void +Silk.NET.Core.IGLContextSource +Silk.NET.Core.IGLContextSource.GLContext.get -> Silk.NET.Core.IGLContext? +Silk.NET.Core.INativeWindow +Silk.NET.Core.INativeWindow.TryGetPlatformInfo(out TPlatformInfo? info) -> bool Silk.NET.Core.Loader.DefaultNativeContext Silk.NET.Core.Loader.DefaultNativeContext.DefaultNativeContext() -> void Silk.NET.Core.Loader.DefaultNativeContext.Dispose() -> void @@ -224,15 +269,70 @@ Silk.NET.Core.SupportedApiProfileAttribute.SupportedApiProfileAttribute(string! Silk.NET.Core.TransformedAttribute Silk.NET.Core.TransformedAttribute.IsTransformed.get -> bool Silk.NET.Core.TransformedAttribute.TransformedAttribute(bool isTransformed = true) -> void +Silk.NET.Core.UIKitPlatformInfo +Silk.NET.Core.UIKitPlatformInfo.ColorBuffer.get -> uint +Silk.NET.Core.UIKitPlatformInfo.ColorBuffer.init -> void +Silk.NET.Core.UIKitPlatformInfo.Framebuffer.get -> uint +Silk.NET.Core.UIKitPlatformInfo.Framebuffer.init -> void +Silk.NET.Core.UIKitPlatformInfo.ResolveFramebuffer.get -> uint +Silk.NET.Core.UIKitPlatformInfo.ResolveFramebuffer.init -> void +Silk.NET.Core.UIKitPlatformInfo.UIKitPlatformInfo() -> void +Silk.NET.Core.UIKitPlatformInfo.UIKitPlatformInfo(nint Window, uint Framebuffer, uint ColorBuffer, uint ResolveFramebuffer) -> void +Silk.NET.Core.UIKitPlatformInfo.Window.get -> nint +Silk.NET.Core.UIKitPlatformInfo.Window.init -> void Silk.NET.Core.Utf8String Silk.NET.Core.Utf8String.Bytes.get -> System.ReadOnlySpan Silk.NET.Core.Utf8String.Utf8String() -> void Silk.NET.Core.Utf8String.Utf8String(System.ReadOnlySpan bytes) -> void Silk.NET.Core.VariantBool Silk.NET.Core.VariantBool.VariantBool() -> void +Silk.NET.Core.Version32 +Silk.NET.Core.Version32.Major.get -> uint +Silk.NET.Core.Version32.Minor.get -> uint +Silk.NET.Core.Version32.Patch.get -> uint +Silk.NET.Core.Version32.Value.get -> uint +Silk.NET.Core.Version32.Variant.get -> uint +Silk.NET.Core.Version32.Version32() -> void +Silk.NET.Core.Version32.Version32(uint major, uint minor, uint patch = 0, uint variant = 0) -> void +Silk.NET.Core.VivantePlatformInfo +Silk.NET.Core.VivantePlatformInfo.Display.get -> nint +Silk.NET.Core.VivantePlatformInfo.Display.init -> void +Silk.NET.Core.VivantePlatformInfo.VivantePlatformInfo() -> void +Silk.NET.Core.VivantePlatformInfo.VivantePlatformInfo(nint Display, nint Window) -> void +Silk.NET.Core.VivantePlatformInfo.Window.get -> nint +Silk.NET.Core.VivantePlatformInfo.Window.init -> void Silk.NET.Core.VtblIndexAttribute Silk.NET.Core.VtblIndexAttribute.Index.get -> uint Silk.NET.Core.VtblIndexAttribute.VtblIndexAttribute(uint index) -> void +Silk.NET.Core.WaylandPlatformInfo +Silk.NET.Core.WaylandPlatformInfo.Display.get -> nint +Silk.NET.Core.WaylandPlatformInfo.Display.init -> void +Silk.NET.Core.WaylandPlatformInfo.Surface.get -> nint +Silk.NET.Core.WaylandPlatformInfo.Surface.init -> void +Silk.NET.Core.WaylandPlatformInfo.WaylandPlatformInfo() -> void +Silk.NET.Core.WaylandPlatformInfo.WaylandPlatformInfo(nint Display, nint Surface) -> void +Silk.NET.Core.Win32PlatformInfo +Silk.NET.Core.Win32PlatformInfo.HDC.get -> nint +Silk.NET.Core.Win32PlatformInfo.HDC.init -> void +Silk.NET.Core.Win32PlatformInfo.HInstance.get -> nint +Silk.NET.Core.Win32PlatformInfo.HInstance.init -> void +Silk.NET.Core.Win32PlatformInfo.Hwnd.get -> nint +Silk.NET.Core.Win32PlatformInfo.Hwnd.init -> void +Silk.NET.Core.Win32PlatformInfo.Win32PlatformInfo() -> void +Silk.NET.Core.Win32PlatformInfo.Win32PlatformInfo(nint Hwnd, nint HDC, nint HInstance) -> void +Silk.NET.Core.WinRTPlatformInfo +Silk.NET.Core.WinRTPlatformInfo.Inspectable.get -> nint +Silk.NET.Core.WinRTPlatformInfo.Inspectable.init -> void +Silk.NET.Core.WinRTPlatformInfo.WinRTPlatformInfo() -> void +Silk.NET.Core.WinRTPlatformInfo.WinRTPlatformInfo(nint Inspectable) -> void +Silk.NET.Core.X11PlatformInfo +Silk.NET.Core.X11PlatformInfo.Display.get -> nint +Silk.NET.Core.X11PlatformInfo.Display.init -> void +Silk.NET.Core.X11PlatformInfo.Window.get -> nint +Silk.NET.Core.X11PlatformInfo.Window.init -> void +Silk.NET.Core.X11PlatformInfo.X11PlatformInfo() -> void +Silk.NET.Core.X11PlatformInfo.X11PlatformInfo(nint Display, nint Window) -> void +static Silk.NET.Core.BreakneckLock.Create() -> Silk.NET.Core.BreakneckLock static Silk.NET.Core.Constant.implicit operator Silk.NET.Core.Constant(TEnum1 value) -> Silk.NET.Core.Constant static Silk.NET.Core.Constant.implicit operator Silk.NET.Core.Constant(TEnum2 value) -> Silk.NET.Core.Constant static Silk.NET.Core.Constant.implicit operator Silk.NET.Core.Constant(TUnderlying value) -> Silk.NET.Core.Constant @@ -314,6 +414,8 @@ static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3 static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? +static Silk.NET.Core.Ptr.explicit operator nint(Silk.NET.Core.Ptr ptr) -> nint +static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(nint ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ref ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.explicit operator string!(Silk.NET.Core.Ptr ptr) -> string! static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ptr @@ -335,10 +437,12 @@ static Silk.NET.Core.Ptr.operator ==(Silk.NET.Core.Ptr lh, void* rh) -> bool static Silk.NET.Core.Ptr.operator ==(Silk.NET.Core.Ref lh, Silk.NET.Core.Ptr rh) -> bool static Silk.NET.Core.Ptr.operator ==(void* lh, Silk.NET.Core.Ptr rh) -> bool static Silk.NET.Core.Ptr2D.explicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr2D +static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ptr* ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(void* ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(void** ptr) -> Silk.NET.Core.Ptr2D +static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ptr2D.implicit operator void*(Silk.NET.Core.Ptr2D ptr) -> void* static Silk.NET.Core.Ptr2D.implicit operator void**(Silk.NET.Core.Ptr2D ptr) -> void** @@ -360,15 +464,17 @@ static Silk.NET.Core.Ptr2D.operator ==(Silk.NET.Core.Ptr2D lh, void** rh) -> boo static Silk.NET.Core.Ptr2D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Core.Ptr2D rh) -> bool static Silk.NET.Core.Ptr2D.operator ==(void* lh, Silk.NET.Core.Ptr2D rh) -> bool static Silk.NET.Core.Ptr2D.operator ==(void** lh, Silk.NET.Core.Ptr2D rh) -> bool +static Silk.NET.Core.Ptr2D.explicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr2D +static Silk.NET.Core.Ptr2D.explicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr2D +static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ptr* ptr) -> Silk.NET.Core.Ptr2D -static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr2D -static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(T** ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(void* ptr) -> Silk.NET.Core.Ptr2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ptr2D(void** ptr) -> Silk.NET.Core.Ptr2D +static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ptr2D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.Ptr2D ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ptr2D.implicit operator T*(Silk.NET.Core.Ptr2D ptr) -> T* @@ -406,12 +512,14 @@ static Silk.NET.Core.Ptr2D.operator ==(T** lh, Silk.NET.Core.Ptr2D rh) -> static Silk.NET.Core.Ptr2D.operator ==(void* lh, Silk.NET.Core.Ptr2D rh) -> bool static Silk.NET.Core.Ptr2D.operator ==(void** lh, Silk.NET.Core.Ptr2D rh) -> bool static Silk.NET.Core.Ptr3D.explicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ptr3D +static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ptr2D* ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void* ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void** ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void*** ptr) -> Silk.NET.Core.Ptr3D -static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref2D +static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref +static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref3D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ptr3D.implicit operator void*(Silk.NET.Core.Ptr3D ptr) -> void* static Silk.NET.Core.Ptr3D.implicit operator void**(Silk.NET.Core.Ptr3D ptr) -> void** static Silk.NET.Core.Ptr3D.implicit operator void***(Silk.NET.Core.Ptr3D ptr) -> void*** @@ -433,16 +541,18 @@ static Silk.NET.Core.Ptr3D.operator ==(Silk.NET.Core.Ptr3D lh, void** rh) -> boo static Silk.NET.Core.Ptr3D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Core.Ptr3D rh) -> bool static Silk.NET.Core.Ptr3D.operator ==(void* lh, Silk.NET.Core.Ptr3D rh) -> bool static Silk.NET.Core.Ptr3D.operator ==(void** lh, Silk.NET.Core.Ptr3D rh) -> bool +static Silk.NET.Core.Ptr3D.explicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ptr3D +static Silk.NET.Core.Ptr3D.explicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ptr3D +static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ptr2D* ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ptr3D -static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ptr3D -static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(T*** ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void* ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void** ptr) -> Silk.NET.Core.Ptr3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ptr3D(void*** ptr) -> Silk.NET.Core.Ptr3D +static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref3D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ptr3D.implicit operator Silk.NET.Core.Ref3D(Silk.NET.Core.Ptr3D ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ptr3D.implicit operator T*(Silk.NET.Core.Ptr3D ptr) -> T* @@ -488,6 +598,7 @@ static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ptr ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ptr(T* ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ptr(void* ptr) -> Silk.NET.Core.Ptr +static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ptr.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ptr ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ptr.implicit operator T*(Silk.NET.Core.Ptr ptr) -> T* static Silk.NET.Core.Ptr.implicit operator void*(Silk.NET.Core.Ptr ptr) -> void* @@ -532,6 +643,7 @@ static Silk.NET.Core.Ref.operator ==(Silk.NET.Core.Ref lh, Silk.NET.Core.NullPtr static Silk.NET.Core.Ref.operator ==(Silk.NET.Core.Ref lh, Silk.NET.Core.Ref rh) -> bool static Silk.NET.Core.Ref2D.explicit operator byte**(Silk.NET.Core.Ref2D ptr) -> byte** static Silk.NET.Core.Ref2D.explicit operator void*(Silk.NET.Core.Ref2D ptr) -> void* +static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(byte** ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(byte*[]! array) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(byte[]![]! array) -> Silk.NET.Core.Ref2D @@ -546,9 +658,10 @@ static Silk.NET.Core.Ref2D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Core.Nul static Silk.NET.Core.Ref2D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Core.Ref2D rh) -> bool static Silk.NET.Core.Ref2D.explicit operator T**(Silk.NET.Core.Ref2D ptr) -> T** static Silk.NET.Core.Ref2D.explicit operator void*(Silk.NET.Core.Ref2D ptr) -> void* +static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.Ref2D ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ref2D -static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(string![]! array) -> Silk.NET.Core.Ref2D +static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(string?[]! array) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(T** ptr) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(T*[]! array) -> Silk.NET.Core.Ref2D static Silk.NET.Core.Ref2D.implicit operator Silk.NET.Core.Ref2D(T[]![]! array) -> Silk.NET.Core.Ref2D @@ -561,6 +674,7 @@ static Silk.NET.Core.Ref2D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Co static Silk.NET.Core.Ref2D.operator ==(Silk.NET.Core.Ref2D lh, Silk.NET.Core.Ref2D rh) -> bool static Silk.NET.Core.Ref3D.explicit operator byte***(Silk.NET.Core.Ref3D ptr) -> byte*** static Silk.NET.Core.Ref3D.explicit operator void*(Silk.NET.Core.Ref3D ptr) -> void* +static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(byte*** ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(byte**[]! array) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(byte[]![]![]! array) -> Silk.NET.Core.Ref3D @@ -575,9 +689,10 @@ static Silk.NET.Core.Ref3D.operator ==(Silk.NET.Core.Ref3D lh, Silk.NET.Core.Nul static Silk.NET.Core.Ref3D.operator ==(Silk.NET.Core.Ref3D lh, Silk.NET.Core.Ref3D rh) -> bool static Silk.NET.Core.Ref3D.explicit operator T***(Silk.NET.Core.Ref3D ptr) -> T*** static Silk.NET.Core.Ref3D.explicit operator void*(Silk.NET.Core.Ref3D ptr) -> void* +static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(Silk.NET.Core.Ref3D ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ref3D -static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(string![]![]! array) -> Silk.NET.Core.Ref3D +static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(string?[]![]! array) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(T*** ptr) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(T**[]! array) -> Silk.NET.Core.Ref3D static Silk.NET.Core.Ref3D.implicit operator Silk.NET.Core.Ref3D(T[]![]![]! array) -> Silk.NET.Core.Ref3D @@ -593,7 +708,7 @@ static Silk.NET.Core.Ref.explicit operator T*(Silk.NET.Core.Ref ptr) -> T* static Silk.NET.Core.Ref.explicit operator void*(Silk.NET.Core.Ref ptr) -> void* static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Ref ptr) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.NullPtr ptr) -> Silk.NET.Core.Ref -static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(string! str) -> Silk.NET.Core.Ref +static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(string? str) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(System.ReadOnlySpan span) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(System.Span span) -> Silk.NET.Core.Ref static Silk.NET.Core.Ref.implicit operator Silk.NET.Core.Ref(T* ptr) -> Silk.NET.Core.Ref @@ -625,10 +740,10 @@ static Silk.NET.Core.SilkMarshal.NativeToString(ref byte native, nint charSize = static Silk.NET.Core.SilkMarshal.NativeToStringArray(System.ReadOnlySpan native, int[]! lengths, nint charSize = 1) -> string?[]?[]? static Silk.NET.Core.SilkMarshal.NativeToStringArray(System.ReadOnlySpan native, int[]! lengths0, int[]! lengths1, nint charSize = 1) -> string?[]?[]?[]? static Silk.NET.Core.SilkMarshal.NativeToStringArray(System.ReadOnlySpan native, nint charSize = 1) -> string?[]? -static Silk.NET.Core.SilkMarshal.StringArrayToArray(System.ReadOnlySpan strs, nint charSize = 1) -> byte[]? -static Silk.NET.Core.SilkMarshal.StringArrayToNative(System.ReadOnlySpan strs, nint charSize = 1) -> byte -static Silk.NET.Core.SilkMarshal.StringArrayToNative(System.ReadOnlySpan strs, nint charSize = 1) -> byte +static Silk.NET.Core.SilkMarshal.StringArrayToArray(System.ReadOnlySpan strs, nint charSize = 1) -> byte[]? static Silk.NET.Core.SilkMarshal.StringArrayToNative(System.ReadOnlySpan strs, nint charSize = 1) -> byte +static Silk.NET.Core.SilkMarshal.StringArrayToNative(System.ReadOnlySpan strs, nint charSize = 1) -> byte +static Silk.NET.Core.SilkMarshal.StringArrayToNative(System.ReadOnlySpan strs, nint charSize = 1) -> byte static Silk.NET.Core.SilkMarshal.StringToArray(System.ReadOnlySpan str, nint charSize = 1) -> byte[]? static Silk.NET.Core.SilkMarshal.StringToNative(System.ReadOnlySpan str, nint charSize = 1) -> byte static Silk.NET.Core.Utf8String.implicit operator Silk.NET.Core.Ref(Silk.NET.Core.Utf8String str) -> Silk.NET.Core.Ref @@ -641,3 +756,7 @@ static Silk.NET.Core.Utf8String.implicit operator System.ReadOnlySpan(Silk static Silk.NET.Core.Utf8String.implicit operator System.ReadOnlySpan(Silk.NET.Core.Utf8String str) -> System.ReadOnlySpan static Silk.NET.Core.VariantBool.IsTrue(T value) -> bool static Silk.NET.Core.VariantBool.True() -> T +static Silk.NET.Core.Version32.explicit operator Silk.NET.Core.Version32(uint val) -> Silk.NET.Core.Version32 +static Silk.NET.Core.Version32.implicit operator Silk.NET.Core.Version32(System.Version! version) -> Silk.NET.Core.Version32 +static Silk.NET.Core.Version32.implicit operator System.Version!(Silk.NET.Core.Version32 version) -> System.Version! +static Silk.NET.Core.Version32.implicit operator uint(Silk.NET.Core.Version32 version) -> uint diff --git a/sources/Core/Core/SilkMarshal.cs b/sources/Core/Core/SilkMarshal.cs index 0c73d7d7c3..0ea5da9f57 100644 --- a/sources/Core/Core/SilkMarshal.cs +++ b/sources/Core/Core/SilkMarshal.cs @@ -167,7 +167,7 @@ public static ref readonly byte StringToNative(ReadOnlySpan str, nint char /// The character size of the marshalled strings. /// /// A GC exception occurred. - public static byte[]? StringArrayToArray(ReadOnlySpan strs, nint charSize = 1) + public static byte[]? StringArrayToArray(ReadOnlySpan strs, nint charSize = 1) { var ret = new byte[strs.Length * sizeof(nint)]; var span = MemoryMarshal.Cast(ret); @@ -198,7 +198,7 @@ public static ref readonly byte StringToNative(ReadOnlySpan str, nint char /// The character size of the marshalled strings. /// The reference. /// A GC exception occurred. - public static ref byte StringArrayToNative(ReadOnlySpan strs, nint charSize = 1) + public static ref byte StringArrayToNative(ReadOnlySpan strs, nint charSize = 1) { var ret = StringArrayToArray(strs, charSize); if (ret is null) @@ -217,7 +217,7 @@ public static ref byte StringArrayToNative(ReadOnlySpan strs, nint charS /// The reference. /// A GC exception occurred. // TODO analyzer to clarify that this only works if the inner array is const. - public static ref byte StringArrayToNative(ReadOnlySpan strs, nint charSize = 1) + public static ref byte StringArrayToNative(ReadOnlySpan strs, nint charSize = 1) { var ret = new byte[strs.Length * sizeof(nint)]; var span = MemoryMarshal.Cast(ret); diff --git a/sources/OpenGL/OpenGL/ContextSourceExtensions.cs b/sources/OpenGL/OpenGL/ContextSourceExtensions.cs new file mode 100644 index 0000000000..1765e169b2 --- /dev/null +++ b/sources/OpenGL/OpenGL/ContextSourceExtensions.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; + +namespace Silk.NET.OpenGL; + +public static class ContextSourceExtensions +{ + private static ConditionalWeakTable _cwt = new(); + + public static IGL CreateOpenGL(this IGLContextSource src) + { + if (src.GLContext is not { } ctx) + { + throw new ArgumentException( + "The given context source does not have an OpenGL context", + nameof(src) + ); + } + + return GL.Create(ctx); + } + + public static IGL CreateOpenGL(this IGLContext ctx) => GL.Create(ctx); + + public static void MakeCurrent(this IGLContextSource src) => src.GLContext?.MakeCurrent(); + + public static void MakeCurrent(this IGLContext ctx) => + GL.ThisThread.MakeCurrent(_cwt.GetValue(ctx, c => c.CreateOpenGL())); +} diff --git a/sources/OpenGL/OpenGL/GL.cs b/sources/OpenGL/OpenGL/GL.cs index 70826747a7..51f75e37c8 100644 --- a/sources/OpenGL/OpenGL/GL.cs +++ b/sources/OpenGL/OpenGL/GL.cs @@ -15,7 +15,7 @@ public static partial void MakeCurrent(IGL ctx) { if (ctx is GL { Context: IGLContext glContext }) { - glContext.MakeCurrent(); + glContext.IsCurrent = true; } Underlying.Value = ctx; diff --git a/sources/Playground/Playground.csproj b/sources/Playground/Playground.csproj index 8752ac2ed3..1749875027 100644 --- a/sources/Playground/Playground.csproj +++ b/sources/Playground/Playground.csproj @@ -11,6 +11,7 @@ + diff --git a/sources/Playground/Program.cs b/sources/Playground/Program.cs index 36f971cec2..2a7afc3c8d 100644 --- a/sources/Playground/Program.cs +++ b/sources/Playground/Program.cs @@ -3,133 +3,107 @@ using System.Runtime.InteropServices; using Silk.NET.Core; using Silk.NET.OpenGL; -using Silk.NET.SDL; +using Silk.NET.Windowing; +using Surface = Silk.NET.Windowing.Surface; -if (!Sdl.Init(uint.MaxValue)) +internal class MyApplication : ISurfaceApplication { - throw new Exception($"failed to init: {(string)Sdl.GetError()}"); -} - -var window = Sdl.CreateWindow( - "Hello Window!", - 1000, - 800, - Sdl.WindowOpengl | Sdl.WindowHighPixelDensity | Sdl.WindowResizable -); -if (window == nullptr) -{ - throw new Exception($"failed to create window: {(string)Sdl.GetError()}"); -} + public static void Initialize(TSurface surface) + where TSurface : Surface + { + float[] vertices = [-0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f]; -Console.WriteLine( - $"SDL_GetDisplayContentScale {Sdl.GetDisplayContentScale(Sdl.GetDisplayForWindow(window))}" -); -Console.WriteLine($"SDL_GetWindowDisplayScale {Sdl.GetWindowDisplayScale(window)}"); -Console.WriteLine($"SDL_GetWindowPixelDensity {Sdl.GetWindowPixelDensity(window)}"); -int sx = 0, - sy = 0, - px = 0, - py = 0; -Sdl.GetWindowSize(window, sx.AsRef(), sy.AsRef()); -Sdl.GetWindowSizeInPixels(window, px.AsRef(), py.AsRef()); -Console.WriteLine($"SDL_GetWindowSize {sx} {sy}"); -Console.WriteLine($"SDL_GetWindowSizeInPixels {px} {py}"); + if (surface.OpenGL is null) + { + throw new PlatformNotSupportedException("OpenGL is not supported."); + } -var context = new SdlContext( - window, - new KeyValuePair(GLAttr.ContextMajorVersion, 3), - new KeyValuePair(GLAttr.ContextMinorVersion, 3), - new KeyValuePair(GLAttr.ContextProfileMask, Sdl.GlContextProfileCore), - new KeyValuePair( - GLAttr.ContextFlags, - Sdl.GlContextForwardCompatibleFlag | Sdl.GlContextDebugFlag - ) -); -GL.ThisThread.MakeCurrent(GL.Create(context)); + // Enable OpenGL context creation for our surface. + surface.OpenGL.Profile = OpenGLContextProfile.Core; + surface.OpenGL.Version = new Version32(3, 3); -float[] vertices = { -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f }; + var vbo = 0u; + var vao = 0u; + var prog = 0u; + surface.Created += _ => + { + // Make the OpenGL context current, this will allow us to use GL static functions. + surface.MakeCurrent(); -var vbo = GL.GenBuffer(); -GL.ClearColor(0.2f, 0.3f, 0.3f, 1.0f); -GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); -GL.BufferData( - BufferTarget.ArrayBuffer, - (nuint)(vertices.Length * sizeof(float)), - vertices[0].AsRef(), // TODO simplify this - BufferUsage.StaticDraw -); + Console.WriteLine("=== BEGIN OPENGL INFORMATION"); +#pragma warning disable IL3050 + foreach (StringName val in Enum.GetValues(typeof(StringName))) +#pragma warning restore IL3050 + { + Console.WriteLine($"{val} = {GL.GetString(val).ReadToString()}"); + } + Console.WriteLine("=== END OPENGL INFORMATION"); -var vao = GL.GenVertexArray(); -GL.BindVertexArray(vao); -GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), nullptr); -GL.EnableVertexAttribArray(0); -var vert = GL.CreateShader(ShaderType.VertexShader); -var frag = GL.CreateShader(ShaderType.FragmentShader); -const string vertSource = """ - #version 330 core - layout(location = 0) in vec3 aPosition; - void main(void) - { - gl_Position = vec4(aPosition, 1.0); - } - """; -var vertSourceLength = vertSource.Length; -GL.ShaderSource(vert, 1, new[] { vertSource }, vertSourceLength.AsRef()); -const string fragSource = """ - #version 330 - out vec4 outputColor; - void main() - { - outputColor = vec4(1.0, 0.5, 0.2, 1.0); - } - """; -var fragSourceLength = fragSource.Length; -GL.ShaderSource(frag, 1, new[] { fragSource }, fragSourceLength.AsRef()); -GL.CompileShader(vert); -GL.CompileShader(frag); -var prog = GL.CreateProgram(); -GL.AttachShader(prog, vert); -GL.AttachShader(prog, frag); -GL.LinkProgram(prog); -GL.DeleteShader(vert); -GL.DeleteShader(frag); -GL.UseProgram(prog); + // Create the vertex buffer. + vbo = GL.GenBuffer(); + GL.ClearColor(0.2f, 0.3f, 0.3f, 1.0f); + GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); + GL.BufferData( + BufferTarget.ArrayBuffer, + (nuint)(vertices.Length * sizeof(float)), + vertices[0].AsRef(), // TODO simplify this + BufferUsage.StaticDraw + ); + vao = GL.GenVertexArray(); + GL.BindVertexArray(vao); + GL.VertexAttribPointer( + 0, + 3, + VertexAttribPointerType.Float, + false, + 3 * sizeof(float), + nullptr + ); + GL.EnableVertexAttribArray(0); + var vert = GL.CreateShader(ShaderType.VertexShader); + var frag = GL.CreateShader(ShaderType.FragmentShader); -Event @event = default; -while (true) -{ - if (Sdl.PollEvent(@event.AsRef())) - { - Console.WriteLine((EventType)@event.Type); - if (@event.Type == (int)EventType.Quit) + const string vertSource = """ + #version 330 core + layout(location = 0) in vec3 aPosition; + void main(void) + { + gl_Position = vec4(aPosition, 1.0); + } + """; + var vertSourceLength = vertSource.Length; + GL.ShaderSource(vert, 1, new[] { vertSource }, vertSourceLength.AsRef()); + const string fragSource = """ + #version 330 + out vec4 outputColor; + void main() + { + outputColor = vec4(1.0, 0.5, 0.2, 1.0); + } + """; + var fragSourceLength = fragSource.Length; + GL.ShaderSource(frag, 1, new[] { fragSource }, fragSourceLength.AsRef()); + GL.CompileShader(vert); + GL.CompileShader(frag); + prog = GL.CreateProgram(); + GL.AttachShader(prog, vert); + GL.AttachShader(prog, frag); + GL.LinkProgram(prog); + GL.DeleteShader(vert); + GL.DeleteShader(frag); + GL.UseProgram(prog); + }; + surface.Render += _ => { - break; - } - } - - if (@event.Window.Type == EventType.WindowDisplayScaleChanged) - { - Console.WriteLine( - $"SDL_GetDisplayContentScale {Sdl.GetDisplayContentScale(Sdl.GetDisplayForWindow(window))}" - ); - Console.WriteLine($"SDL_GetWindowDisplayScale {Sdl.GetWindowDisplayScale(window)}"); - Console.WriteLine($"SDL_GetWindowPixelDensity {Sdl.GetWindowPixelDensity(window)}"); - } - - if (@event.Window.Type == EventType.WindowResized) - { - Sdl.GetWindowSize(window, sx.AsRef(), sy.AsRef()); - Sdl.GetWindowSizeInPixels(window, px.AsRef(), py.AsRef()); - Console.WriteLine($"SDL_GetWindowSize {sx} {sy}"); - Console.WriteLine($"SDL_GetWindowSizeInPixels {px} {py}"); + GL.Clear(ClearBufferMask.ColorBufferBit); + GL.DrawArrays(PrimitiveType.Triangles, 0, 3); + }; + surface.Terminating += _ => + { + GL.DeleteVertexArray(vao); + GL.DeleteBuffer(vbo); + }; } - GL.Clear(ClearBufferMask.ColorBufferBit); - GL.DrawArrays(PrimitiveType.Triangles, 0, 3); - context.SwapBuffers(); + public static void Main() => ISurfaceApplication.Run(); } - -GL.DeleteVertexArray(vao); -GL.DeleteBuffer(vbo); -Sdl.DestroyWindow(window); -Sdl.Quit(); diff --git a/sources/SDL/SDL/Extensions.cs b/sources/SDL/SDL/Extensions.cs new file mode 100644 index 0000000000..00369b0e9e --- /dev/null +++ b/sources/SDL/SDL/Extensions.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.SDL; + +public partial class Sdl +{ + public static void ThrowError() + { + if (GetError().ReadToString() is { Length: > 0 } str) + { + static void Throw(string str) => throw new SdlException(str); + Throw(str); + } + } +} + +public static class Extensions +{ + public static void ThrowError(this ISdl sdl) + { + if (sdl.GetError().ReadToString() is { Length: > 0 } str) + { + static void Throw(string str) => throw new SdlException(str); + Throw(str); + sdl.ClearError(); + } + } + + public static void ThrowSdlError(this bool ec) + { + if (!ec) + { + Sdl.ThrowError(); + } + } + + public static void ThrowSdlError(this bool ec, ISdl sdl) + { + if (!ec) + { + sdl.ThrowError(); + } + } +} diff --git a/sources/SDL/SDL/Handles/EnvironmentHandle.gen.cs b/sources/SDL/SDL/Handles/EnvironmentHandle.gen.cs new file mode 100644 index 0000000000..7279b2c212 --- /dev/null +++ b/sources/SDL/SDL/Handles/EnvironmentHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct EnvironmentHandle +{ + public readonly void* Handle; + + public bool Equals(EnvironmentHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is EnvironmentHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(EnvironmentHandle left, EnvironmentHandle right) => + left.Equals(right); + + public static bool operator !=(EnvironmentHandle left, EnvironmentHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(EnvironmentHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(EnvironmentHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator EnvironmentHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUBufferHandle.gen.cs b/sources/SDL/SDL/Handles/GPUBufferHandle.gen.cs new file mode 100644 index 0000000000..c557229232 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUBufferHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUBufferHandle +{ + public readonly void* Handle; + + public bool Equals(GPUBufferHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUBufferHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUBufferHandle left, GPUBufferHandle right) => + left.Equals(right); + + public static bool operator !=(GPUBufferHandle left, GPUBufferHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUBufferHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUBufferHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUBufferHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUCommandBufferHandle.gen.cs b/sources/SDL/SDL/Handles/GPUCommandBufferHandle.gen.cs new file mode 100644 index 0000000000..445f074f04 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUCommandBufferHandle.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUCommandBufferHandle +{ + public readonly void* Handle; + + public bool Equals(GPUCommandBufferHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => + obj is GPUCommandBufferHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUCommandBufferHandle left, GPUCommandBufferHandle right) => + left.Equals(right); + + public static bool operator !=(GPUCommandBufferHandle left, GPUCommandBufferHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUCommandBufferHandle left, NullPtr right) => + left.Equals(right); + + public static bool operator !=(GPUCommandBufferHandle left, NullPtr right) => + !left.Equals(right); + + public static implicit operator GPUCommandBufferHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUComputePassHandle.gen.cs b/sources/SDL/SDL/Handles/GPUComputePassHandle.gen.cs new file mode 100644 index 0000000000..49f4f349f2 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUComputePassHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUComputePassHandle +{ + public readonly void* Handle; + + public bool Equals(GPUComputePassHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUComputePassHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUComputePassHandle left, GPUComputePassHandle right) => + left.Equals(right); + + public static bool operator !=(GPUComputePassHandle left, GPUComputePassHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUComputePassHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUComputePassHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUComputePassHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUComputePipelineHandle.gen.cs b/sources/SDL/SDL/Handles/GPUComputePipelineHandle.gen.cs new file mode 100644 index 0000000000..f4df196194 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUComputePipelineHandle.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUComputePipelineHandle +{ + public readonly void* Handle; + + public bool Equals(GPUComputePipelineHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => + obj is GPUComputePipelineHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUComputePipelineHandle left, GPUComputePipelineHandle right) => + left.Equals(right); + + public static bool operator !=(GPUComputePipelineHandle left, GPUComputePipelineHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUComputePipelineHandle left, NullPtr right) => + left.Equals(right); + + public static bool operator !=(GPUComputePipelineHandle left, NullPtr right) => + !left.Equals(right); + + public static implicit operator GPUComputePipelineHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUCopyPassHandle.gen.cs b/sources/SDL/SDL/Handles/GPUCopyPassHandle.gen.cs new file mode 100644 index 0000000000..0619b36dc3 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUCopyPassHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUCopyPassHandle +{ + public readonly void* Handle; + + public bool Equals(GPUCopyPassHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUCopyPassHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUCopyPassHandle left, GPUCopyPassHandle right) => + left.Equals(right); + + public static bool operator !=(GPUCopyPassHandle left, GPUCopyPassHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUCopyPassHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUCopyPassHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUCopyPassHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUDeviceHandle.gen.cs b/sources/SDL/SDL/Handles/GPUDeviceHandle.gen.cs new file mode 100644 index 0000000000..8a043d0115 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUDeviceHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUDeviceHandle +{ + public readonly void* Handle; + + public bool Equals(GPUDeviceHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUDeviceHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUDeviceHandle left, GPUDeviceHandle right) => + left.Equals(right); + + public static bool operator !=(GPUDeviceHandle left, GPUDeviceHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUDeviceHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUDeviceHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUDeviceHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUFenceHandle.gen.cs b/sources/SDL/SDL/Handles/GPUFenceHandle.gen.cs new file mode 100644 index 0000000000..f049db501f --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUFenceHandle.gen.cs @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUFenceHandle +{ + public readonly void* Handle; + + public bool Equals(GPUFenceHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUFenceHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUFenceHandle left, GPUFenceHandle right) => left.Equals(right); + + public static bool operator !=(GPUFenceHandle left, GPUFenceHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUFenceHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUFenceHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUFenceHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUGraphicsPipelineHandle.gen.cs b/sources/SDL/SDL/Handles/GPUGraphicsPipelineHandle.gen.cs new file mode 100644 index 0000000000..095280c368 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUGraphicsPipelineHandle.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUGraphicsPipelineHandle +{ + public readonly void* Handle; + + public bool Equals(GPUGraphicsPipelineHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => + obj is GPUGraphicsPipelineHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==( + GPUGraphicsPipelineHandle left, + GPUGraphicsPipelineHandle right + ) => left.Equals(right); + + public static bool operator !=( + GPUGraphicsPipelineHandle left, + GPUGraphicsPipelineHandle right + ) => !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUGraphicsPipelineHandle left, NullPtr right) => + left.Equals(right); + + public static bool operator !=(GPUGraphicsPipelineHandle left, NullPtr right) => + !left.Equals(right); + + public static implicit operator GPUGraphicsPipelineHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPURenderPassHandle.gen.cs b/sources/SDL/SDL/Handles/GPURenderPassHandle.gen.cs new file mode 100644 index 0000000000..245a458958 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPURenderPassHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPURenderPassHandle +{ + public readonly void* Handle; + + public bool Equals(GPURenderPassHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPURenderPassHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPURenderPassHandle left, GPURenderPassHandle right) => + left.Equals(right); + + public static bool operator !=(GPURenderPassHandle left, GPURenderPassHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPURenderPassHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPURenderPassHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPURenderPassHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUSamplerHandle.gen.cs b/sources/SDL/SDL/Handles/GPUSamplerHandle.gen.cs new file mode 100644 index 0000000000..d8a77c1a61 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUSamplerHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUSamplerHandle +{ + public readonly void* Handle; + + public bool Equals(GPUSamplerHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUSamplerHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUSamplerHandle left, GPUSamplerHandle right) => + left.Equals(right); + + public static bool operator !=(GPUSamplerHandle left, GPUSamplerHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUSamplerHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUSamplerHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUSamplerHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUShaderHandle.gen.cs b/sources/SDL/SDL/Handles/GPUShaderHandle.gen.cs new file mode 100644 index 0000000000..3bd7d613cc --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUShaderHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUShaderHandle +{ + public readonly void* Handle; + + public bool Equals(GPUShaderHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUShaderHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUShaderHandle left, GPUShaderHandle right) => + left.Equals(right); + + public static bool operator !=(GPUShaderHandle left, GPUShaderHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUShaderHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUShaderHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUShaderHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUTextureHandle.gen.cs b/sources/SDL/SDL/Handles/GPUTextureHandle.gen.cs new file mode 100644 index 0000000000..d3a5c30219 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUTextureHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUTextureHandle +{ + public readonly void* Handle; + + public bool Equals(GPUTextureHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is GPUTextureHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUTextureHandle left, GPUTextureHandle right) => + left.Equals(right); + + public static bool operator !=(GPUTextureHandle left, GPUTextureHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUTextureHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(GPUTextureHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator GPUTextureHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/GPUTransferBufferHandle.gen.cs b/sources/SDL/SDL/Handles/GPUTransferBufferHandle.gen.cs new file mode 100644 index 0000000000..936ef75ce8 --- /dev/null +++ b/sources/SDL/SDL/Handles/GPUTransferBufferHandle.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct GPUTransferBufferHandle +{ + public readonly void* Handle; + + public bool Equals(GPUTransferBufferHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => + obj is GPUTransferBufferHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(GPUTransferBufferHandle left, GPUTransferBufferHandle right) => + left.Equals(right); + + public static bool operator !=(GPUTransferBufferHandle left, GPUTransferBufferHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(GPUTransferBufferHandle left, NullPtr right) => + left.Equals(right); + + public static bool operator !=(GPUTransferBufferHandle left, NullPtr right) => + !left.Equals(right); + + public static implicit operator GPUTransferBufferHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/IconvDataTHandle.gen.cs b/sources/SDL/SDL/Handles/IconvDataTHandle.gen.cs new file mode 100644 index 0000000000..a0b1dd3004 --- /dev/null +++ b/sources/SDL/SDL/Handles/IconvDataTHandle.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct IconvDataTHandle +{ + public readonly void* Handle; + + public bool Equals(IconvDataTHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is IconvDataTHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(IconvDataTHandle left, IconvDataTHandle right) => + left.Equals(right); + + public static bool operator !=(IconvDataTHandle left, IconvDataTHandle right) => + !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(IconvDataTHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(IconvDataTHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator IconvDataTHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/Handles/ProcessHandle.gen.cs b/sources/SDL/SDL/Handles/ProcessHandle.gen.cs new file mode 100644 index 0000000000..73e0e253b0 --- /dev/null +++ b/sources/SDL/SDL/Handles/ProcessHandle.gen.cs @@ -0,0 +1,32 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe partial struct ProcessHandle +{ + public readonly void* Handle; + + public bool Equals(ProcessHandle other) => Handle == other.Handle; + + public override bool Equals(object? obj) => obj is ProcessHandle other && Equals(other); + + public override int GetHashCode() => HashCode.Combine((nuint)Handle); + + public static bool operator ==(ProcessHandle left, ProcessHandle right) => left.Equals(right); + + public static bool operator !=(ProcessHandle left, ProcessHandle right) => !left.Equals(right); + + public bool Equals(NullPtr _) => Handle is null; + + public static bool operator ==(ProcessHandle left, NullPtr right) => left.Equals(right); + + public static bool operator !=(ProcessHandle left, NullPtr right) => !left.Equals(right); + + public static implicit operator ProcessHandle(NullPtr _) => default; +} diff --git a/sources/SDL/SDL/SDL3/AlignmentTest.gen.cs b/sources/SDL/SDL/SDL3/AlignmentTest.gen.cs new file mode 100644 index 0000000000..ee82d755fa --- /dev/null +++ b/sources/SDL/SDL/SDL3/AlignmentTest.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct AlignmentTest +{ + [NativeTypeName("Uint8")] + public byte A; + public void* B; +} diff --git a/sources/SDL/SDL/SDL3/AppEventFunc.gen.cs b/sources/SDL/SDL/SDL3/AppEventFunc.gen.cs new file mode 100644 index 0000000000..f4522827b0 --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppEventFunc.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct AppEventFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public AppEventFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public AppEventFunc(AppEventFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator AppEventFunc( + delegate* unmanaged pfn + ) => new(pfn); + + public static implicit operator delegate* unmanaged( + AppEventFunc pfn + ) => (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/AppEventFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/AppEventFuncDelegate.gen.cs new file mode 100644 index 0000000000..5f2625f42b --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppEventFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate AppResult AppEventFuncDelegate(void* arg0, Event* arg1); diff --git a/sources/SDL/SDL/SDL3/AppInitFunc.gen.cs b/sources/SDL/SDL/SDL3/AppInitFunc.gen.cs new file mode 100644 index 0000000000..b15d3487aa --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppInitFunc.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct AppInitFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public AppInitFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public AppInitFunc(AppInitFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator AppInitFunc( + delegate* unmanaged pfn + ) => new(pfn); + + public static implicit operator delegate* unmanaged( + AppInitFunc pfn + ) => (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/AppInitFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/AppInitFuncDelegate.gen.cs new file mode 100644 index 0000000000..02fdd738ce --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppInitFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate AppResult AppInitFuncDelegate(void** arg0, int arg1, sbyte** arg2); diff --git a/sources/SDL/SDL/SDL3/AppIterateFunc.gen.cs b/sources/SDL/SDL/SDL3/AppIterateFunc.gen.cs new file mode 100644 index 0000000000..43ba3b9bd8 --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppIterateFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct AppIterateFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public AppIterateFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public AppIterateFunc(AppIterateFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator AppIterateFunc(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(AppIterateFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/AppIterateFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/AppIterateFuncDelegate.gen.cs new file mode 100644 index 0000000000..d733874414 --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppIterateFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate AppResult AppIterateFuncDelegate(void* arg0); diff --git a/sources/SDL/SDL/SDL3/AppQuitFunc.gen.cs b/sources/SDL/SDL/SDL3/AppQuitFunc.gen.cs new file mode 100644 index 0000000000..1c9ebf3e2a --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppQuitFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct AppQuitFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public AppQuitFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public AppQuitFunc(AppQuitFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator AppQuitFunc(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(AppQuitFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/AppQuitFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/AppQuitFuncDelegate.gen.cs new file mode 100644 index 0000000000..4412c681c1 --- /dev/null +++ b/sources/SDL/SDL/SDL3/AppQuitFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate void AppQuitFuncDelegate(void* arg0, AppResult arg1); diff --git a/sources/SDL/SDL/SDL3/CallocFunc.gen.cs b/sources/SDL/SDL/SDL3/CallocFunc.gen.cs new file mode 100644 index 0000000000..01fcab5a9b --- /dev/null +++ b/sources/SDL/SDL/SDL3/CallocFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct CallocFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public CallocFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public CallocFunc(CallocFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator CallocFunc(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(CallocFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/CallocFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/CallocFuncDelegate.gen.cs new file mode 100644 index 0000000000..0c1b3f7558 --- /dev/null +++ b/sources/SDL/SDL/SDL3/CallocFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate void* CallocFuncDelegate(nuint arg0, nuint arg1); diff --git a/sources/SDL/SDL/SDL3/CompareCallback.gen.cs b/sources/SDL/SDL/SDL3/CompareCallback.gen.cs new file mode 100644 index 0000000000..f10a2b62c4 --- /dev/null +++ b/sources/SDL/SDL/SDL3/CompareCallback.gen.cs @@ -0,0 +1,29 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct CompareCallback : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public CompareCallback(delegate* unmanaged ptr) => Pointer = ptr; + + public CompareCallback(CompareCallbackDelegate proc) => + Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator CompareCallback(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(CompareCallback pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/CompareCallbackDelegate.gen.cs b/sources/SDL/SDL/SDL3/CompareCallbackDelegate.gen.cs new file mode 100644 index 0000000000..b78168b0a8 --- /dev/null +++ b/sources/SDL/SDL/SDL3/CompareCallbackDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate int CompareCallbackDelegate(void* arg0, void* arg1); diff --git a/sources/SDL/SDL/SDL3/CompareCallbackR.gen.cs b/sources/SDL/SDL/SDL3/CompareCallbackR.gen.cs new file mode 100644 index 0000000000..76112a2a8c --- /dev/null +++ b/sources/SDL/SDL/SDL3/CompareCallbackR.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct CompareCallbackR : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public CompareCallbackR(delegate* unmanaged ptr) => Pointer = ptr; + + public CompareCallbackR(CompareCallbackRDelegate proc) => + Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator CompareCallbackR( + delegate* unmanaged pfn + ) => new(pfn); + + public static implicit operator delegate* unmanaged( + CompareCallbackR pfn + ) => (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/CompareCallbackRDelegate.gen.cs b/sources/SDL/SDL/SDL3/CompareCallbackRDelegate.gen.cs new file mode 100644 index 0000000000..9fbfcc2a6b --- /dev/null +++ b/sources/SDL/SDL/SDL3/CompareCallbackRDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate int CompareCallbackRDelegate(void* arg0, void* arg1, void* arg2); diff --git a/sources/SDL/SDL/SDL3/DummyEnum.gen.cs b/sources/SDL/SDL/SDL3/DummyEnum.gen.cs new file mode 100644 index 0000000000..2b7d1445b3 --- /dev/null +++ b/sources/SDL/SDL/SDL3/DummyEnum.gen.cs @@ -0,0 +1,14 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum DummyEnum : uint +{ + DummyEnumValue, +} diff --git a/sources/SDL/SDL/SDL3/FreeFunc.gen.cs b/sources/SDL/SDL/SDL3/FreeFunc.gen.cs new file mode 100644 index 0000000000..d50de5aa94 --- /dev/null +++ b/sources/SDL/SDL/SDL3/FreeFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct FreeFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => (delegate* unmanaged)Pointer; + + public FreeFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public FreeFunc(FreeFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator FreeFunc(delegate* unmanaged pfn) => new(pfn); + + public static implicit operator delegate* unmanaged(FreeFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/FreeFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/FreeFuncDelegate.gen.cs new file mode 100644 index 0000000000..eef174453b --- /dev/null +++ b/sources/SDL/SDL/SDL3/FreeFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate void FreeFuncDelegate(void* arg0); diff --git a/sources/SDL/SDL/SDL3/GLattr.gen.cs b/sources/SDL/SDL/SDL3/GLAttr.gen.cs similarity index 100% rename from sources/SDL/SDL/SDL3/GLattr.gen.cs rename to sources/SDL/SDL/SDL3/GLAttr.gen.cs diff --git a/sources/SDL/SDL/SDL3/GPUBlendFactor.gen.cs b/sources/SDL/SDL/SDL3/GPUBlendFactor.gen.cs new file mode 100644 index 0000000000..48cd7d4f67 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBlendFactor.gen.cs @@ -0,0 +1,27 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUBlendFactor : uint +{ + Invalid, + Zero, + One, + SrcColor, + OneMinusSrcColor, + DstColor, + OneMinusDstColor, + SrcAlpha, + OneMinusSrcAlpha, + DstAlpha, + OneMinusDstAlpha, + ConstantColor, + OneMinusConstantColor, + SrcAlphaSaturate, +} diff --git a/sources/SDL/SDL/SDL3/GPUBlendOp.gen.cs b/sources/SDL/SDL/SDL3/GPUBlendOp.gen.cs new file mode 100644 index 0000000000..515d70a357 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBlendOp.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUBlendOp : uint +{ + Invalid, + Add, + Subtract, + ReverseSubtract, + Min, + Max, +} diff --git a/sources/SDL/SDL/SDL3/GPUBlitInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUBlitInfo.gen.cs new file mode 100644 index 0000000000..3bcfbd0311 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBlitInfo.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUBlitInfo +{ + public GPUBlitRegion Source; + public GPUBlitRegion Destination; + public GPULoadOp LoadOp; + public FColor ClearColor; + public FlipMode FlipMode; + public GPUFilter Filter; + + [NativeTypeName("bool")] + public byte Cycle; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUBlitRegion.gen.cs b/sources/SDL/SDL/SDL3/GPUBlitRegion.gen.cs new file mode 100644 index 0000000000..931855db86 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBlitRegion.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUBlitRegion +{ + public GPUTextureHandle Texture; + + [NativeTypeName("Uint32")] + public uint MipLevel; + + [NativeTypeName("Uint32")] + public uint LayerOrDepthPlane; + + [NativeTypeName("Uint32")] + public uint X; + + [NativeTypeName("Uint32")] + public uint Y; + + [NativeTypeName("Uint32")] + public uint W; + + [NativeTypeName("Uint32")] + public uint H; +} diff --git a/sources/SDL/SDL/SDL3/GPUBufferBinding.gen.cs b/sources/SDL/SDL/SDL3/GPUBufferBinding.gen.cs new file mode 100644 index 0000000000..fea0ad4db0 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBufferBinding.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUBufferBinding +{ + public GPUBufferHandle Buffer; + + [NativeTypeName("Uint32")] + public uint Offset; +} diff --git a/sources/SDL/SDL/SDL3/GPUBufferCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUBufferCreateInfo.gen.cs new file mode 100644 index 0000000000..a106e2fea6 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBufferCreateInfo.gen.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUBufferCreateInfo +{ + [NativeTypeName("SDL_GPUBufferUsageFlags")] + public uint Usage; + + [NativeTypeName("Uint32")] + public uint Size; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUBufferLocation.gen.cs b/sources/SDL/SDL/SDL3/GPUBufferLocation.gen.cs new file mode 100644 index 0000000000..9da59a8775 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBufferLocation.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUBufferLocation +{ + public GPUBufferHandle Buffer; + + [NativeTypeName("Uint32")] + public uint Offset; +} diff --git a/sources/SDL/SDL/SDL3/GPUBufferRegion.gen.cs b/sources/SDL/SDL/SDL3/GPUBufferRegion.gen.cs new file mode 100644 index 0000000000..a3313ef108 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUBufferRegion.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUBufferRegion +{ + public GPUBufferHandle Buffer; + + [NativeTypeName("Uint32")] + public uint Offset; + + [NativeTypeName("Uint32")] + public uint Size; +} diff --git a/sources/SDL/SDL/SDL3/GPUColorTargetBlendState.gen.cs b/sources/SDL/SDL/SDL3/GPUColorTargetBlendState.gen.cs new file mode 100644 index 0000000000..0e8d566ae2 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUColorTargetBlendState.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUColorTargetBlendState +{ + public GPUBlendFactor SrcColorBlendfactor; + public GPUBlendFactor DstColorBlendfactor; + public GPUBlendOp ColorBlendOp; + public GPUBlendFactor SrcAlphaBlendfactor; + public GPUBlendFactor DstAlphaBlendfactor; + public GPUBlendOp AlphaBlendOp; + + [NativeTypeName("SDL_GPUColorComponentFlags")] + public byte ColorWriteMask; + + [NativeTypeName("bool")] + public byte EnableBlend; + + [NativeTypeName("bool")] + public byte EnableColorWriteMask; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; +} diff --git a/sources/SDL/SDL/SDL3/GPUColorTargetDescription.gen.cs b/sources/SDL/SDL/SDL3/GPUColorTargetDescription.gen.cs new file mode 100644 index 0000000000..da6f9799ec --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUColorTargetDescription.gen.cs @@ -0,0 +1,14 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUColorTargetDescription +{ + public GPUTextureFormat Format; + public GPUColorTargetBlendState BlendState; +} diff --git a/sources/SDL/SDL/SDL3/GPUColorTargetInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUColorTargetInfo.gen.cs new file mode 100644 index 0000000000..8b51bfcffc --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUColorTargetInfo.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUColorTargetInfo +{ + public GPUTextureHandle Texture; + + [NativeTypeName("Uint32")] + public uint MipLevel; + + [NativeTypeName("Uint32")] + public uint LayerOrDepthPlane; + public FColor ClearColor; + public GPULoadOp LoadOp; + public GPUStoreOp StoreOp; + public GPUTextureHandle ResolveTexture; + + [NativeTypeName("Uint32")] + public uint ResolveMipLevel; + + [NativeTypeName("Uint32")] + public uint ResolveLayer; + + [NativeTypeName("bool")] + public byte Cycle; + + [NativeTypeName("bool")] + public byte CycleResolveTexture; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; +} diff --git a/sources/SDL/SDL/SDL3/GPUCompareOp.gen.cs b/sources/SDL/SDL/SDL3/GPUCompareOp.gen.cs new file mode 100644 index 0000000000..3915854161 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUCompareOp.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUCompareOp : uint +{ + Invalid, + Never, + Less, + Equal, + LessOrEqual, + Greater, + NotEqual, + GreaterOrEqual, + Always, +} diff --git a/sources/SDL/SDL/SDL3/GPUComputePipelineCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUComputePipelineCreateInfo.gen.cs new file mode 100644 index 0000000000..88097630f8 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUComputePipelineCreateInfo.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUComputePipelineCreateInfo +{ + [NativeTypeName("size_t")] + public nuint CodeSize; + + [NativeTypeName("const Uint8 *")] + public byte* Code; + + [NativeTypeName("const char *")] + public sbyte* Entrypoint; + + [NativeTypeName("SDL_GPUShaderFormat")] + public uint Format; + + [NativeTypeName("Uint32")] + public uint NumSamplers; + + [NativeTypeName("Uint32")] + public uint NumReadonlyStorageTextures; + + [NativeTypeName("Uint32")] + public uint NumReadonlyStorageBuffers; + + [NativeTypeName("Uint32")] + public uint NumReadwriteStorageTextures; + + [NativeTypeName("Uint32")] + public uint NumReadwriteStorageBuffers; + + [NativeTypeName("Uint32")] + public uint NumUniformBuffers; + + [NativeTypeName("Uint32")] + public uint ThreadcountX; + + [NativeTypeName("Uint32")] + public uint ThreadcountY; + + [NativeTypeName("Uint32")] + public uint ThreadcountZ; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUCubeMapFace.gen.cs b/sources/SDL/SDL/SDL3/GPUCubeMapFace.gen.cs new file mode 100644 index 0000000000..28e851e8e0 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUCubeMapFace.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUCubeMapFace : uint +{ + Positivex, + Negativex, + Positivey, + Negativey, + Positivez, + Negativez, +} diff --git a/sources/SDL/SDL/SDL3/GPUCullMode.gen.cs b/sources/SDL/SDL/SDL3/GPUCullMode.gen.cs new file mode 100644 index 0000000000..72197fed27 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUCullMode.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUCullMode : uint +{ + None, + Front, + Back, +} diff --git a/sources/SDL/SDL/SDL3/GPUDepthStencilState.gen.cs b/sources/SDL/SDL/SDL3/GPUDepthStencilState.gen.cs new file mode 100644 index 0000000000..ab93cffc72 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUDepthStencilState.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +namespace Silk.NET.SDL; + +public partial struct GPUDepthStencilState +{ + public GPUCompareOp CompareOp; + public GPUStencilOpState BackStencilState; + public GPUStencilOpState FrontStencilState; + + [NativeTypeName("Uint8")] + public byte CompareMask; + + [NativeTypeName("Uint8")] + public byte WriteMask; + + [NativeTypeName("bool")] + public byte EnableDepthTest; + + [NativeTypeName("bool")] + public byte EnableDepthWrite; + + [NativeTypeName("bool")] + public byte EnableStencilTest; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUDepthStencilTargetInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUDepthStencilTargetInfo.gen.cs new file mode 100644 index 0000000000..af8da1098a --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUDepthStencilTargetInfo.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUDepthStencilTargetInfo +{ + public GPUTextureHandle Texture; + public float ClearDepth; + public GPULoadOp LoadOp; + public GPUStoreOp StoreOp; + public GPULoadOp StencilLoadOp; + public GPUStoreOp StencilStoreOp; + + [NativeTypeName("bool")] + public byte Cycle; + + [NativeTypeName("Uint8")] + public byte ClearStencil; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; +} diff --git a/sources/SDL/SDL/SDL3/GPUFillMode.gen.cs b/sources/SDL/SDL/SDL3/GPUFillMode.gen.cs new file mode 100644 index 0000000000..cbc040be4f --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUFillMode.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUFillMode : uint +{ + Fill, + Line, +} diff --git a/sources/SDL/SDL/SDL3/GPUFilter.gen.cs b/sources/SDL/SDL/SDL3/GPUFilter.gen.cs new file mode 100644 index 0000000000..37fe243c71 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUFilter.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUFilter : uint +{ + Nearest, + Linear, +} diff --git a/sources/SDL/SDL/SDL3/GPUFrontFace.gen.cs b/sources/SDL/SDL/SDL3/GPUFrontFace.gen.cs new file mode 100644 index 0000000000..9ce6e11ea6 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUFrontFace.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUFrontFace : uint +{ + CounterClockwise, + Clockwise, +} diff --git a/sources/SDL/SDL/SDL3/GPUGraphicsPipelineCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUGraphicsPipelineCreateInfo.gen.cs new file mode 100644 index 0000000000..da9b2daa77 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUGraphicsPipelineCreateInfo.gen.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUGraphicsPipelineCreateInfo +{ + public GPUShaderHandle VertexShader; + public GPUShaderHandle FragmentShader; + public GPUVertexInputState VertexInputState; + public GPUPrimitiveType PrimitiveType; + public GPURasterizerState RasterizerState; + public GPUMultisampleState MultisampleState; + public GPUDepthStencilState DepthStencilState; + public GPUGraphicsPipelineTargetInfo TargetInfo; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUGraphicsPipelineTargetInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUGraphicsPipelineTargetInfo.gen.cs new file mode 100644 index 0000000000..dbc66f361b --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUGraphicsPipelineTargetInfo.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUGraphicsPipelineTargetInfo +{ + [NativeTypeName("const SDL_GPUColorTargetDescription *")] + public GPUColorTargetDescription* ColorTargetDescriptions; + + [NativeTypeName("Uint32")] + public uint NumColorTargets; + public GPUTextureFormat DepthStencilFormat; + + [NativeTypeName("bool")] + public byte HasDepthStencilTarget; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUIndexElementSize.gen.cs b/sources/SDL/SDL/SDL3/GPUIndexElementSize.gen.cs new file mode 100644 index 0000000000..fff2c4d313 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUIndexElementSize.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUIndexElementSize : uint +{ + Indexelementsize16Bit, + Indexelementsize32Bit, +} diff --git a/sources/SDL/SDL/SDL3/GPUIndexedIndirectDrawCommand.gen.cs b/sources/SDL/SDL/SDL3/GPUIndexedIndirectDrawCommand.gen.cs new file mode 100644 index 0000000000..bc17a4dc1c --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUIndexedIndirectDrawCommand.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUIndexedIndirectDrawCommand +{ + [NativeTypeName("Uint32")] + public uint NumIndices; + + [NativeTypeName("Uint32")] + public uint NumInstances; + + [NativeTypeName("Uint32")] + public uint FirstIndex; + + [NativeTypeName("Sint32")] + public int VertexOffset; + + [NativeTypeName("Uint32")] + public uint FirstInstance; +} diff --git a/sources/SDL/SDL/SDL3/GPUIndirectDispatchCommand.gen.cs b/sources/SDL/SDL/SDL3/GPUIndirectDispatchCommand.gen.cs new file mode 100644 index 0000000000..5d335fd96b --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUIndirectDispatchCommand.gen.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUIndirectDispatchCommand +{ + [NativeTypeName("Uint32")] + public uint GroupcountX; + + [NativeTypeName("Uint32")] + public uint GroupcountY; + + [NativeTypeName("Uint32")] + public uint GroupcountZ; +} diff --git a/sources/SDL/SDL/SDL3/GPUIndirectDrawCommand.gen.cs b/sources/SDL/SDL/SDL3/GPUIndirectDrawCommand.gen.cs new file mode 100644 index 0000000000..9e311d137d --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUIndirectDrawCommand.gen.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUIndirectDrawCommand +{ + [NativeTypeName("Uint32")] + public uint NumVertices; + + [NativeTypeName("Uint32")] + public uint NumInstances; + + [NativeTypeName("Uint32")] + public uint FirstVertex; + + [NativeTypeName("Uint32")] + public uint FirstInstance; +} diff --git a/sources/SDL/SDL/SDL3/GPULoadOp.gen.cs b/sources/SDL/SDL/SDL3/GPULoadOp.gen.cs new file mode 100644 index 0000000000..81d8819c8f --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPULoadOp.gen.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPULoadOp : uint +{ + Load, + Clear, + DontCare, +} diff --git a/sources/SDL/SDL/SDL3/GPUMultisampleState.gen.cs b/sources/SDL/SDL/SDL3/GPUMultisampleState.gen.cs new file mode 100644 index 0000000000..91652d0650 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUMultisampleState.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUMultisampleState +{ + public GPUSampleCount SampleCount; + + [NativeTypeName("Uint32")] + public uint SampleMask; + + [NativeTypeName("bool")] + public byte EnableMask; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUPresentMode.gen.cs b/sources/SDL/SDL/SDL3/GPUPresentMode.gen.cs new file mode 100644 index 0000000000..8a08d19cd2 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUPresentMode.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUPresentMode : uint +{ + Vsync, + Immediate, + Mailbox, +} diff --git a/sources/SDL/SDL/SDL3/GPUPrimitiveType.gen.cs b/sources/SDL/SDL/SDL3/GPUPrimitiveType.gen.cs new file mode 100644 index 0000000000..d4193e1767 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUPrimitiveType.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUPrimitiveType : uint +{ + Trianglelist, + Trianglestrip, + Linelist, + Linestrip, + Pointlist, +} diff --git a/sources/SDL/SDL/SDL3/GPURasterizerState.gen.cs b/sources/SDL/SDL/SDL3/GPURasterizerState.gen.cs new file mode 100644 index 0000000000..46b3265b69 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPURasterizerState.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPURasterizerState +{ + public GPUFillMode FillMode; + public GPUCullMode CullMode; + public GPUFrontFace FrontFace; + public float DepthBiasConstantFactor; + public float DepthBiasClamp; + public float DepthBiasSlopeFactor; + + [NativeTypeName("bool")] + public byte EnableDepthBias; + + [NativeTypeName("bool")] + public byte EnableDepthClip; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; +} diff --git a/sources/SDL/SDL/SDL3/GPUSampleCount.gen.cs b/sources/SDL/SDL/SDL3/GPUSampleCount.gen.cs new file mode 100644 index 0000000000..001e0d151b --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUSampleCount.gen.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUSampleCount : uint +{ + Samplecount1, + Samplecount2, + Samplecount4, + Samplecount8, +} diff --git a/sources/SDL/SDL/SDL3/GPUSamplerAddressMode.gen.cs b/sources/SDL/SDL/SDL3/GPUSamplerAddressMode.gen.cs new file mode 100644 index 0000000000..69dfea2c4f --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUSamplerAddressMode.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUSamplerAddressMode : uint +{ + Repeat, + MirroredRepeat, + ClampToEdge, +} diff --git a/sources/SDL/SDL/SDL3/GPUSamplerCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUSamplerCreateInfo.gen.cs new file mode 100644 index 0000000000..d3071290db --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUSamplerCreateInfo.gen.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUSamplerCreateInfo +{ + public GPUFilter MinFilter; + public GPUFilter MagFilter; + public GPUSamplerMipmapMode MipmapMode; + public GPUSamplerAddressMode AddressModeU; + public GPUSamplerAddressMode AddressModeV; + public GPUSamplerAddressMode AddressModeW; + public float MipLodBias; + public float MaxAnisotropy; + public GPUCompareOp CompareOp; + public float MinLod; + public float MaxLod; + + [NativeTypeName("bool")] + public byte EnableAnisotropy; + + [NativeTypeName("bool")] + public byte EnableCompare; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUSamplerMipmapMode.gen.cs b/sources/SDL/SDL/SDL3/GPUSamplerMipmapMode.gen.cs new file mode 100644 index 0000000000..08c394b643 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUSamplerMipmapMode.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUSamplerMipmapMode : uint +{ + Nearest, + Linear, +} diff --git a/sources/SDL/SDL/SDL3/GPUShaderCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUShaderCreateInfo.gen.cs new file mode 100644 index 0000000000..aead37de9b --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUShaderCreateInfo.gen.cs @@ -0,0 +1,40 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUShaderCreateInfo +{ + [NativeTypeName("size_t")] + public nuint CodeSize; + + [NativeTypeName("const Uint8 *")] + public byte* Code; + + [NativeTypeName("const char *")] + public sbyte* Entrypoint; + + [NativeTypeName("SDL_GPUShaderFormat")] + public uint Format; + public GPUShaderStage Stage; + + [NativeTypeName("Uint32")] + public uint NumSamplers; + + [NativeTypeName("Uint32")] + public uint NumStorageTextures; + + [NativeTypeName("Uint32")] + public uint NumStorageBuffers; + + [NativeTypeName("Uint32")] + public uint NumUniformBuffers; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUShaderStage.gen.cs b/sources/SDL/SDL/SDL3/GPUShaderStage.gen.cs new file mode 100644 index 0000000000..4fc03eaf1e --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUShaderStage.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUShaderStage : uint +{ + Vertex, + Fragment, +} diff --git a/sources/SDL/SDL/SDL3/GPUStencilOp.gen.cs b/sources/SDL/SDL/SDL3/GPUStencilOp.gen.cs new file mode 100644 index 0000000000..59192abfa1 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUStencilOp.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUStencilOp : uint +{ + Invalid, + Keep, + Zero, + Replace, + IncrementAndClamp, + DecrementAndClamp, + Invert, + IncrementAndWrap, + DecrementAndWrap, +} diff --git a/sources/SDL/SDL/SDL3/GPUStencilOpState.gen.cs b/sources/SDL/SDL/SDL3/GPUStencilOpState.gen.cs new file mode 100644 index 0000000000..a4a641a137 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUStencilOpState.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUStencilOpState +{ + public GPUStencilOp FailOp; + public GPUStencilOp PassOp; + public GPUStencilOp DepthFailOp; + public GPUCompareOp CompareOp; +} diff --git a/sources/SDL/SDL/SDL3/GPUStorageBufferReadWriteBinding.gen.cs b/sources/SDL/SDL/SDL3/GPUStorageBufferReadWriteBinding.gen.cs new file mode 100644 index 0000000000..b8b04e4f2f --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUStorageBufferReadWriteBinding.gen.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUStorageBufferReadWriteBinding +{ + public GPUBufferHandle Buffer; + + [NativeTypeName("bool")] + public byte Cycle; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUStorageTextureReadWriteBinding.gen.cs b/sources/SDL/SDL/SDL3/GPUStorageTextureReadWriteBinding.gen.cs new file mode 100644 index 0000000000..3668b913b6 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUStorageTextureReadWriteBinding.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUStorageTextureReadWriteBinding +{ + public GPUTextureHandle Texture; + + [NativeTypeName("Uint32")] + public uint MipLevel; + + [NativeTypeName("Uint32")] + public uint Layer; + + [NativeTypeName("bool")] + public byte Cycle; + + [NativeTypeName("Uint8")] + public byte Padding1; + + [NativeTypeName("Uint8")] + public byte Padding2; + + [NativeTypeName("Uint8")] + public byte Padding3; +} diff --git a/sources/SDL/SDL/SDL3/GPUStoreOp.gen.cs b/sources/SDL/SDL/SDL3/GPUStoreOp.gen.cs new file mode 100644 index 0000000000..835cee5cc2 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUStoreOp.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUStoreOp : uint +{ + Store, + DontCare, + Resolve, + ResolveAndStore, +} diff --git a/sources/SDL/SDL/SDL3/GPUSwapchainComposition.gen.cs b/sources/SDL/SDL/SDL3/GPUSwapchainComposition.gen.cs new file mode 100644 index 0000000000..7c0626e8c3 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUSwapchainComposition.gen.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUSwapchainComposition : uint +{ + Sdr, + SdrLinear, + HdrExtendedLinear, + Hdr10St2048, +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureCreateInfo.gen.cs new file mode 100644 index 0000000000..4a4038c640 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureCreateInfo.gen.cs @@ -0,0 +1,30 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +namespace Silk.NET.SDL; + +public partial struct GPUTextureCreateInfo +{ + public GPUTextureType Type; + public GPUTextureFormat Format; + + [NativeTypeName("SDL_GPUTextureUsageFlags")] + public uint Usage; + + [NativeTypeName("Uint32")] + public uint Width; + + [NativeTypeName("Uint32")] + public uint Height; + + [NativeTypeName("Uint32")] + public uint LayerCountOrDepth; + + [NativeTypeName("Uint32")] + public uint NumLevels; + public GPUSampleCount SampleCount; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureFormat.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureFormat.gen.cs new file mode 100644 index 0000000000..1e53aaa28e --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureFormat.gen.cs @@ -0,0 +1,118 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUTextureFormat : uint +{ + Invalid, + A8Unorm, + R8Unorm, + R8G8Unorm, + R8G8B8A8Unorm, + R16Unorm, + R16G16Unorm, + R16G16B16A16Unorm, + R10G10B10A2Unorm, + B5G6R5Unorm, + B5G5R5A1Unorm, + B4G4R4A4Unorm, + B8G8R8A8Unorm, + Bc1RgbaUnorm, + Bc2RgbaUnorm, + Bc3RgbaUnorm, + Bc4RUnorm, + Bc5RgUnorm, + Bc7RgbaUnorm, + Bc6HRgbFloat, + Bc6HRgbUfloat, + R8Snorm, + R8G8Snorm, + R8G8B8A8Snorm, + R16Snorm, + R16G16Snorm, + R16G16B16A16Snorm, + R16Float, + R16G16Float, + R16G16B16A16Float, + R32Float, + R32G32Float, + R32G32B32A32Float, + R11G11B10Ufloat, + R8Uint, + R8G8Uint, + R8G8B8A8Uint, + R16Uint, + R16G16Uint, + R16G16B16A16Uint, + R32Uint, + R32G32Uint, + R32G32B32A32Uint, + R8Int, + R8G8Int, + R8G8B8A8Int, + R16Int, + R16G16Int, + R16G16B16A16Int, + R32Int, + R32G32Int, + R32G32B32A32Int, + R8G8B8A8UnormSrgb, + B8G8R8A8UnormSrgb, + Bc1RgbaUnormSrgb, + Bc2RgbaUnormSrgb, + Bc3RgbaUnormSrgb, + Bc7RgbaUnormSrgb, + D16Unorm, + D24Unorm, + D32Float, + D24UnormS8Uint, + D32FloatS8Uint, + Astc4X4Unorm, + Astc5X4Unorm, + Astc5X5Unorm, + Astc6X5Unorm, + Astc6X6Unorm, + Astc8X5Unorm, + Astc8X6Unorm, + Astc8X8Unorm, + Astc10X5Unorm, + Astc10X6Unorm, + Astc10X8Unorm, + Astc10X10Unorm, + Astc12X10Unorm, + Astc12X12Unorm, + Astc4X4UnormSrgb, + Astc5X4UnormSrgb, + Astc5X5UnormSrgb, + Astc6X5UnormSrgb, + Astc6X6UnormSrgb, + Astc8X5UnormSrgb, + Astc8X6UnormSrgb, + Astc8X8UnormSrgb, + Astc10X5UnormSrgb, + Astc10X6UnormSrgb, + Astc10X8UnormSrgb, + Astc10X10UnormSrgb, + Astc12X10UnormSrgb, + Astc12X12UnormSrgb, + Astc4X4Float, + Astc5X4Float, + Astc5X5Float, + Astc6X5Float, + Astc6X6Float, + Astc8X5Float, + Astc8X6Float, + Astc8X8Float, + Astc10X5Float, + Astc10X6Float, + Astc10X8Float, + Astc10X10Float, + Astc12X10Float, + Astc12X12Float, +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureLocation.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureLocation.gen.cs new file mode 100644 index 0000000000..e155fbeaa5 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureLocation.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUTextureLocation +{ + public GPUTextureHandle Texture; + + [NativeTypeName("Uint32")] + public uint MipLevel; + + [NativeTypeName("Uint32")] + public uint Layer; + + [NativeTypeName("Uint32")] + public uint X; + + [NativeTypeName("Uint32")] + public uint Y; + + [NativeTypeName("Uint32")] + public uint Z; +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureRegion.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureRegion.gen.cs new file mode 100644 index 0000000000..ee1b9f7c0b --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureRegion.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUTextureRegion +{ + public GPUTextureHandle Texture; + + [NativeTypeName("Uint32")] + public uint MipLevel; + + [NativeTypeName("Uint32")] + public uint Layer; + + [NativeTypeName("Uint32")] + public uint X; + + [NativeTypeName("Uint32")] + public uint Y; + + [NativeTypeName("Uint32")] + public uint Z; + + [NativeTypeName("Uint32")] + public uint W; + + [NativeTypeName("Uint32")] + public uint H; + + [NativeTypeName("Uint32")] + public uint D; +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureSamplerBinding.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureSamplerBinding.gen.cs new file mode 100644 index 0000000000..724ef91b4f --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureSamplerBinding.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUTextureSamplerBinding +{ + public GPUTextureHandle Texture; + public GPUSamplerHandle Sampler; +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureTransferInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureTransferInfo.gen.cs new file mode 100644 index 0000000000..3843ed64ae --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureTransferInfo.gen.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUTextureTransferInfo +{ + public GPUTransferBufferHandle TransferBuffer; + + [NativeTypeName("Uint32")] + public uint Offset; + + [NativeTypeName("Uint32")] + public uint PixelsPerRow; + + [NativeTypeName("Uint32")] + public uint RowsPerLayer; +} diff --git a/sources/SDL/SDL/SDL3/GPUTextureType.gen.cs b/sources/SDL/SDL/SDL3/GPUTextureType.gen.cs new file mode 100644 index 0000000000..f3a1095ae7 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTextureType.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUTextureType : uint +{ + Texturetype2D, + Texturetype2DArray, + Texturetype3D, + TexturetypeCube, + TexturetypeCubeArray, +} diff --git a/sources/SDL/SDL/SDL3/GPUTransferBufferCreateInfo.gen.cs b/sources/SDL/SDL/SDL3/GPUTransferBufferCreateInfo.gen.cs new file mode 100644 index 0000000000..80474f7a41 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTransferBufferCreateInfo.gen.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUTransferBufferCreateInfo +{ + public GPUTransferBufferUsage Usage; + + [NativeTypeName("Uint32")] + public uint Size; + + [NativeTypeName("SDL_PropertiesID")] + public uint Props; +} diff --git a/sources/SDL/SDL/SDL3/GPUTransferBufferLocation.gen.cs b/sources/SDL/SDL/SDL3/GPUTransferBufferLocation.gen.cs new file mode 100644 index 0000000000..8b2d6e0324 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTransferBufferLocation.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUTransferBufferLocation +{ + public GPUTransferBufferHandle TransferBuffer; + + [NativeTypeName("Uint32")] + public uint Offset; +} diff --git a/sources/SDL/SDL/SDL3/GPUTransferBufferUsage.gen.cs b/sources/SDL/SDL/SDL3/GPUTransferBufferUsage.gen.cs new file mode 100644 index 0000000000..101d6ad536 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUTransferBufferUsage.gen.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUTransferBufferUsage : uint +{ + Upload, + Download, +} diff --git a/sources/SDL/SDL/SDL3/GPUVertexAttribute.gen.cs b/sources/SDL/SDL/SDL3/GPUVertexAttribute.gen.cs new file mode 100644 index 0000000000..d3137cf204 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUVertexAttribute.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUVertexAttribute +{ + [NativeTypeName("Uint32")] + public uint Location; + + [NativeTypeName("Uint32")] + public uint BufferSlot; + public GPUVertexElementFormat Format; + + [NativeTypeName("Uint32")] + public uint Offset; +} diff --git a/sources/SDL/SDL/SDL3/GPUVertexBufferDescription.gen.cs b/sources/SDL/SDL/SDL3/GPUVertexBufferDescription.gen.cs new file mode 100644 index 0000000000..5e856e0e59 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUVertexBufferDescription.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUVertexBufferDescription +{ + [NativeTypeName("Uint32")] + public uint Slot; + + [NativeTypeName("Uint32")] + public uint Pitch; + public GPUVertexInputRate InputRate; + + [NativeTypeName("Uint32")] + public uint InstanceStepRate; +} diff --git a/sources/SDL/SDL/SDL3/GPUVertexElementFormat.gen.cs b/sources/SDL/SDL/SDL3/GPUVertexElementFormat.gen.cs new file mode 100644 index 0000000000..7ba8aedc10 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUVertexElementFormat.gen.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUVertexElementFormat : uint +{ + Invalid, + Int, + Int2, + Int3, + Int4, + Uint, + Uint2, + Uint3, + Uint4, + Float, + Float2, + Float3, + Float4, + Byte2, + Byte4, + Ubyte2, + Ubyte4, + Byte2Norm, + Byte4Norm, + Ubyte2Norm, + Ubyte4Norm, + Short2, + Short4, + Ushort2, + Ushort4, + Short2Norm, + Short4Norm, + Ushort2Norm, + Ushort4Norm, + Half2, + Half4, +} diff --git a/sources/SDL/SDL/SDL3/GPUVertexInputRate.gen.cs b/sources/SDL/SDL/SDL3/GPUVertexInputRate.gen.cs new file mode 100644 index 0000000000..9d653b7384 --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUVertexInputRate.gen.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum GPUVertexInputRate : uint +{ + Vertex, + Instance, +} diff --git a/sources/SDL/SDL/SDL3/GPUVertexInputState.gen.cs b/sources/SDL/SDL/SDL3/GPUVertexInputState.gen.cs new file mode 100644 index 0000000000..89c4ed77df --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUVertexInputState.gen.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe partial struct GPUVertexInputState +{ + [NativeTypeName("const SDL_GPUVertexBufferDescription *")] + public GPUVertexBufferDescription* VertexBufferDescriptions; + + [NativeTypeName("Uint32")] + public uint NumVertexBuffers; + + [NativeTypeName("const SDL_GPUVertexAttribute *")] + public GPUVertexAttribute* VertexAttributes; + + [NativeTypeName("Uint32")] + public uint NumVertexAttributes; +} diff --git a/sources/SDL/SDL/SDL3/GPUViewport.gen.cs b/sources/SDL/SDL/SDL3/GPUViewport.gen.cs new file mode 100644 index 0000000000..ed5b6bad7e --- /dev/null +++ b/sources/SDL/SDL/SDL3/GPUViewport.gen.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public partial struct GPUViewport +{ + public float X; + public float Y; + public float W; + public float H; + public float MinDepth; + public float MaxDepth; +} diff --git a/sources/SDL/SDL/SDL3/ISdl.gen.cs b/sources/SDL/SDL/SDL3/ISdl.gen.cs index fd0a111078..2787295289 100644 --- a/sources/SDL/SDL/SDL3/ISdl.gen.cs +++ b/sources/SDL/SDL/SDL3/ISdl.gen.cs @@ -12,6 +12,15 @@ public unsafe partial interface ISdl { public partial interface Static { + [NativeFunction("SDL3", EntryPoint = "SDL_abs")] + static abstract int Abs(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_acos")] + static abstract double Acos(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_acosf")] + static abstract float Acosf(float x); + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] static abstract Surface* AcquireCameraFrame( CameraHandle camera, @@ -25,6 +34,30 @@ static abstract Ptr AcquireCameraFrame( [NativeTypeName("Uint64 *")] Ref timestampNS ); + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUCommandBuffer")] + static abstract GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + static abstract byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + static abstract MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ); + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] static abstract int AddAtomicInt(AtomicInt* a, int v); @@ -160,6 +193,58 @@ static abstract byte AddVulkanRenderSemaphoresRaw( [NativeTypeName("Sint64")] long signal_semaphore ); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + static abstract Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + static abstract void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + static abstract void AlignedFree(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + static abstract void AlignedFree(Ref mem); + + [NativeFunction("SDL3", EntryPoint = "SDL_asin")] + static abstract double Asin(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_asinf")] + static abstract float Asinf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan")] + static abstract double Atan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2")] + static abstract double Atan2(double y, double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2f")] + static abstract float Atan2F(float y, float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atanf")] + static abstract float Atanf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + static abstract double Atof([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + static abstract double Atof([NativeTypeName("const char *")] Ref str); + + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + static abstract int Atoi([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + static abstract int Atoi([NativeTypeName("const char *")] Ref str); + [return: NativeTypeName("SDL_JoystickID")] [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] static abstract uint AttachVirtualJoystick( @@ -184,6 +269,53 @@ static abstract MaybeBool AudioDevicePaused( [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] static abstract byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev); + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + static abstract GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + static abstract GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUCopyPass")] + static abstract GPUCopyPassHandle BeginGPUCopyPass(GPUCommandBufferHandle command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + static abstract GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + static abstract GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] @@ -216,6 +348,222 @@ static abstract MaybeBool BindAudioStreams( int num_streams ); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputePipeline")] + static abstract void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + static abstract void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + static abstract void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + static abstract void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + static abstract void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + static abstract void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + static abstract void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + static abstract void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + static abstract void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + static abstract void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + static abstract void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + static abstract void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + static abstract void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUGraphicsPipeline")] + static abstract void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + static abstract void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + static abstract void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + static abstract void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + static abstract void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + static abstract void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + static abstract void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + static abstract void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + static abstract void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + static abstract void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + static abstract void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + static abstract void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + static abstract void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] static abstract byte BlitSurface( @@ -372,6 +720,79 @@ ScaleMode scaleMode [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] static abstract void BroadcastCondition(ConditionHandle cond); + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + static abstract void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + static abstract Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + static abstract void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + static abstract Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CalculateGPUTextureFormatSize")] + static abstract uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + static abstract Ptr Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + static abstract void* CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + static abstract MaybeBool CancelGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + static abstract byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] static abstract byte CaptureMouse([NativeTypeName("bool")] byte enabled); @@ -383,6 +804,27 @@ static abstract MaybeBool CaptureMouse( [NativeTypeName("bool")] MaybeBool enabled ); + [NativeFunction("SDL3", EntryPoint = "SDL_ceil")] + static abstract double Ceil(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_ceilf")] + static abstract float Ceilf(float x); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + static abstract MaybeBool ClaimWindowForGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + static abstract byte ClaimWindowForGPUDeviceRaw( + GPUDeviceHandle device, + WindowHandle window + ); + [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] static abstract void CleanupTLS(); @@ -683,6 +1125,48 @@ static abstract MaybeBool CopyFile( [NativeTypeName("const char *")] Ref newpath ); + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + static abstract void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + static abstract void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + static abstract void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + static abstract void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] @@ -698,6 +1182,12 @@ static abstract byte CopyPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint dst ); + [NativeFunction("SDL3", EntryPoint = "SDL_copysign")] + static abstract double Copysign(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_copysignf")] + static abstract float Copysignf(float x, float y); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] static abstract byte CopyStorageFile( @@ -715,6 +1205,46 @@ static abstract MaybeBool CopyStorageFile( [NativeTypeName("const char *")] Ref newpath ); + [NativeFunction("SDL3", EntryPoint = "SDL_cos")] + static abstract double Cos(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_cosf")] + static abstract float Cosf(float x); + + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + static abstract ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint16")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + static abstract ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + static abstract uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + static abstract uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] static abstract AudioStreamHandle CreateAudioStream( [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, @@ -770,6 +1300,136 @@ static abstract MaybeBool CreateDirectory( [NativeTypeName("const char *")] Ref path ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + static abstract EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] byte populated + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + static abstract EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] MaybeBool populated + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + static abstract GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + static abstract GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + static abstract GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + static abstract GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + static abstract GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + static abstract GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDeviceWithProperties")] + static abstract GPUDeviceHandle CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + static abstract GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + static abstract GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + static abstract GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + static abstract GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + static abstract GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + static abstract GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + static abstract GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + static abstract GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + static abstract GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + static abstract GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] static abstract int CreateHapticEffect( HapticHandle haptic, @@ -803,6 +1463,24 @@ static abstract WindowHandle CreatePopupWindow( [NativeTypeName("SDL_WindowFlags")] ulong flags ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + static abstract ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + static abstract ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcessWithProperties")] + static abstract ProcessHandle CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + [return: NativeTypeName("SDL_PropertiesID")] [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] static abstract uint CreateProperties(); @@ -1049,6 +1727,12 @@ static abstract MaybeBool DateTimeToTime( [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] static abstract void DestroyCursor(CursorHandle cursor); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyEnvironment")] + static abstract void DestroyEnvironment(EnvironmentHandle env); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyGPUDevice")] + static abstract void DestroyGPUDevice(GPUDeviceHandle device); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] static abstract void DestroyHapticEffect(HapticHandle haptic, int effect); @@ -1062,6 +1746,9 @@ static abstract MaybeBool DateTimeToTime( [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] static abstract void DestroyPalette(Ref palette); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProcess")] + static abstract void DestroyProcess(ProcessHandle process); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] static abstract void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props); @@ -1125,19 +1812,103 @@ static abstract byte DetachVirtualJoystickRaw( [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] static abstract byte DisableScreenSaverRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] - static abstract Surface* DuplicateSurface(Surface* surface); + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUCompute")] + static abstract void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] - static abstract Ptr DuplicateSurface(Ref surface); + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUComputeIndirect")] + static abstract void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] + static abstract void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ); - [return: NativeTypeName("SDL_EGLConfig")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] - static abstract Ptr EGLGetCurrentConfig(); + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] + static abstract void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination + ); - [return: NativeTypeName("SDL_EGLConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] + static abstract void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + GPUTextureTransferInfo* destination + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] + static abstract void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitives")] + static abstract void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect")] + static abstract void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitives")] + static abstract void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] + static abstract void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + static abstract Surface* DuplicateSurface(Surface* surface); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + static abstract Ptr DuplicateSurface(Ref surface); + + [return: NativeTypeName("SDL_EGLConfig")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + static abstract Ptr EGLGetCurrentConfig(); + + [return: NativeTypeName("SDL_EGLConfig")] [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] static abstract void* EGLGetCurrentConfigRaw(); @@ -1200,6 +1971,36 @@ Ref userdata [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] static abstract byte EnableScreenSaverRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUComputePass")] + static abstract void EndGPUComputePass(GPUComputePassHandle compute_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUCopyPass")] + static abstract void EndGPUCopyPass(GPUCopyPassHandle copy_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPURenderPass")] + static abstract void EndGPURenderPass(GPURenderPassHandle render_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + static abstract int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + static abstract int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] static abstract byte EnumerateDirectory( @@ -1264,6 +2065,15 @@ Ref userdata [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] static abstract byte EventEnabledRaw([NativeTypeName("Uint32")] uint type); + [NativeFunction("SDL3", EntryPoint = "SDL_exp")] + static abstract double Exp(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_expf")] + static abstract float Expf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_fabs")] + static abstract double Fabs(double x); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] static abstract byte FillSurfaceRect( @@ -1331,6 +2141,12 @@ Ref userdata [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] static abstract MaybeBool FlipSurface(Ref surface, FlipMode flip); + [NativeFunction("SDL3", EntryPoint = "SDL_floor")] + static abstract double Floor(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_floorf")] + static abstract float Floorf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] @@ -1367,6 +2183,19 @@ static abstract void FlushEvents( [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] static abstract byte FlushRendererRaw(RendererHandle renderer); + [NativeFunction("SDL3", EntryPoint = "SDL_fmod")] + static abstract double Fmod(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_fmodf")] + static abstract float Fmodf(float x, float y); + + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + static abstract void Free(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + static abstract void Free(Ref mem); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] @@ -1427,6 +2256,12 @@ SensorType type [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] static abstract byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type); + [NativeFunction("SDL3", EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] + static abstract void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ); + [return: NativeTypeName("const char *")] [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] static abstract sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name); @@ -1982,6 +2817,51 @@ static abstract MaybeBool GetDisplayUsableBounds( Ref rect ); + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] + static abstract sbyte* Getenv([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] + static abstract Ptr Getenv([NativeTypeName("const char *")] Ref name); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] + static abstract sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] + static abstract Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironment")] + static abstract EnvironmentHandle GetEnvironment(); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] + static abstract sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] + static abstract Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ); + + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + static abstract Ptr2D GetEnvironmentVariables(EnvironmentHandle env); + + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + static abstract sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env); + [return: NativeTypeName("const char *")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] @@ -2412,6 +3292,34 @@ static abstract ushort GetGamepadVendorForID( [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] static abstract uint GetGlobalProperties(); + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] + static abstract Ptr GetGPUDeviceDriver(GPUDeviceHandle device); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] + static abstract sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] + static abstract Ptr GetGPUDriver(int index); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] + static abstract sbyte* GetGPUDriverRaw(int index); + + [return: NativeTypeName("SDL_GPUShaderFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUShaderFormats")] + static abstract uint GetGPUShaderFormats(GPUDeviceHandle device); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] + static abstract GPUTextureFormat GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ); + [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] static abstract WindowHandle GetGrabbedWindow(); @@ -2830,6 +3738,23 @@ static abstract MaybeBool GetMasksForPixelFormat( [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] static abstract int GetMaxHapticEffectsPlaying(HapticHandle haptic); + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + static abstract void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + static abstract void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ); + [return: NativeTypeName("SDL_MouseID *")] [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] static abstract uint* GetMice(int* count); @@ -2873,6 +3798,9 @@ static abstract DisplayOrientation GetNaturalDisplayOrientation( [NativeTypeName("SDL_DisplayID")] uint displayID ); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAllocations")] + static abstract int GetNumAllocations(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] static abstract int GetNumAudioDrivers(); @@ -2902,6 +3830,9 @@ static abstract long GetNumberProperty( [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] static abstract int GetNumGamepadTouchpads(GamepadHandle gamepad); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGPUDrivers")] + static abstract int GetNumGPUDrivers(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] static abstract int GetNumHapticAxes(HapticHandle haptic); @@ -2926,6 +3857,23 @@ static abstract long GetNumberProperty( [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] static abstract int GetNumVideoDrivers(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + static abstract void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + static abstract void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] static abstract byte GetPathInfo( @@ -3042,6 +3990,16 @@ static abstract Ptr GetPrefPath( [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] static abstract sbyte* GetPrimarySelectionTextRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessInput")] + static abstract IOStreamHandle GetProcessInput(ProcessHandle process); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessOutput")] + static abstract IOStreamHandle GetProcessOutput(ProcessHandle process); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessProperties")] + static abstract uint GetProcessProperties(ProcessHandle process); + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] static abstract PropertyType GetPropertyType( [NativeTypeName("SDL_PropertiesID")] uint props, @@ -4393,6 +5351,74 @@ static abstract Ptr2D GlobStorageDirectory( Ref count ); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] + static abstract MaybeBool GPUSupportsProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] + static abstract byte GPUSupportsPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] + static abstract byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] + static abstract MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] + static abstract uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] + static abstract MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] + static abstract byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + static abstract MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + static abstract byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ); + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] static abstract void GuidToString( Guid guid, @@ -4962,6 +5988,64 @@ static abstract int HidWrite( [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] static abstract byte HideWindowRaw(WindowHandle window); + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + static abstract nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + static abstract nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_close")] + static abstract int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd); + + [return: NativeTypeName("SDL_iconv_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + static abstract IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ); + + [return: NativeTypeName("SDL_iconv_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + static abstract IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] + static abstract sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] + static abstract Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Init")] @@ -4989,6 +6073,19 @@ static abstract int HidWrite( [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] static abstract byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags); + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + static abstract void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + static abstract void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ); + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] static abstract IOStreamHandle IOFromConstMem( [NativeTypeName("const void *")] void* mem, @@ -5042,6 +6139,21 @@ static abstract nuint IOvprintf( [NativeTypeName("va_list")] Ref ap ); + [NativeFunction("SDL3", EntryPoint = "SDL_isalnum")] + static abstract int Isalnum(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isalpha")] + static abstract int Isalpha(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isblank")] + static abstract int Isblank(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_iscntrl")] + static abstract int Iscntrl(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isdigit")] + static abstract int Isdigit(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] @@ -5053,6 +6165,15 @@ static abstract MaybeBool IsGamepad( [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] static abstract byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id); + [NativeFunction("SDL3", EntryPoint = "SDL_isgraph")] + static abstract int Isgraph(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isinf")] + static abstract int Isinf(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isinff")] + static abstract int Isinff(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] @@ -5075,6 +6196,9 @@ static abstract byte IsJoystickVirtualRaw( [NativeTypeName("SDL_JoystickID")] uint instance_id ); + [NativeFunction("SDL3", EntryPoint = "SDL_islower")] + static abstract int Islower(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] @@ -5084,6 +6208,21 @@ static abstract byte IsJoystickVirtualRaw( [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] static abstract byte IsMouseHapticRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_isnan")] + static abstract int Isnan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isnanf")] + static abstract int Isnanf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isprint")] + static abstract int Isprint(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_ispunct")] + static abstract int Ispunct(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isspace")] + static abstract int Isspace(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] @@ -5102,6 +6241,25 @@ static abstract byte IsJoystickVirtualRaw( [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] static abstract byte IsTVRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_isupper")] + static abstract int Isupper(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isxdigit")] + static abstract int Isxdigit(int x); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + static abstract sbyte* Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + static abstract Ptr Itoa( + int value, + [NativeTypeName("char *")] Ref str, + int radix + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] @@ -5120,6 +6278,38 @@ static abstract byte IsJoystickVirtualRaw( [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] static abstract byte JoystickEventsEnabledRaw(); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + static abstract byte KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte force + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + static abstract MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + static abstract sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + static abstract Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] static abstract Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file); @@ -5318,6 +6508,18 @@ static abstract MaybeBool LockTextureToSurface( Ref2D surface ); + [NativeFunction("SDL3", EntryPoint = "SDL_log")] + static abstract double Log(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_log10")] + static abstract double Log10(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_log10f")] + static abstract float Log10F(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_logf")] + static abstract float Logf(float x); + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] static abstract void LogMessageV( int category, @@ -5335,6 +6537,60 @@ static abstract void LogMessageV( [NativeTypeName("va_list")] Ref ap ); + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lround")] + static abstract nint Lround(double x); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lroundf")] + static abstract nint Lroundf(float x); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + static abstract sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + static abstract Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + static abstract int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + static abstract int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + static abstract Ptr Malloc([NativeTypeName("size_t")] nuint size); + + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + static abstract void* MallocRaw([NativeTypeName("size_t")] nuint size); + + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + static abstract void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + static abstract Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ); + [return: NativeTypeName("Uint32")] [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] static abstract uint MapRGB( @@ -5428,12 +6684,42 @@ static abstract uint MapSurfaceRgba( [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] static abstract byte MaximizeWindowRaw(WindowHandle window); + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + static abstract int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + static abstract int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ); + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] static abstract void MemoryBarrierAcquireFunction(); [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] static abstract void MemoryBarrierReleaseFunction(); + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + static abstract void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + static abstract Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ); + [return: NativeTypeName("SDL_MetalView")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] @@ -5487,6 +6773,37 @@ static abstract MaybeBool MixAudio( float volume ); + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + static abstract double Modf(double x, double* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + static abstract double Modf(double x, Ref y); + + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + static abstract float Modff(float x, float* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + static abstract float Modff(float x, Ref y); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + static abstract uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + static abstract uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ); + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] static abstract void OnApplicationDidEnterBackground(); @@ -5727,6 +7044,15 @@ static abstract byte PlayHapticRumbleRaw( [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] static abstract MaybeBool PollEvent(Ref @event); + [NativeFunction("SDL3", EntryPoint = "SDL_PopGPUDebugGroup")] + static abstract void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_pow")] + static abstract double Pow(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_powf")] + static abstract float Powf(float x, float y); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] static abstract byte PremultiplyAlpha( @@ -5783,11 +7109,75 @@ static abstract MaybeBool PremultiplySurfaceAlpha( [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] static abstract MaybeBool PushEvent(Ref @event); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] - static abstract byte PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] void* buf, + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + static abstract void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + static abstract void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + static abstract void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + static abstract void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + static abstract void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + static abstract void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + static abstract void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + static abstract void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + static abstract byte PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] void* buf, int len ); @@ -5800,6 +7190,51 @@ static abstract MaybeBool PutAudioStreamData( int len ); + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + static abstract void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + static abstract void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + static abstract void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + static abstract void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + static abstract MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + static abstract byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence); + [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] static abstract void Quit(); @@ -5815,6 +7250,48 @@ int len [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] static abstract byte RaiseWindowRaw(WindowHandle window); + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand")] + static abstract int Rand([NativeTypeName("Sint32")] int n); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits")] + static abstract uint RandBits(); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + static abstract uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + static abstract uint RandBitsR([NativeTypeName("Uint64 *")] Ref state); + + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + static abstract int RandR( + [NativeTypeName("Uint64 *")] ulong* state, + [NativeTypeName("Sint32")] int n + ); + + [return: NativeTypeName("Sint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + static abstract int RandR( + [NativeTypeName("Uint64 *")] Ref state, + [NativeTypeName("Sint32")] int n + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf")] + static abstract float Randf(); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + static abstract float RandfR([NativeTypeName("Uint64 *")] ulong* state); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + static abstract float RandfR([NativeTypeName("Uint64 *")] Ref state); + [return: NativeTypeName("size_t")] [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] static abstract nuint ReadIO( @@ -5832,6 +7309,21 @@ static abstract nuint ReadIO( [NativeTypeName("size_t")] nuint size ); + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + static abstract void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + static abstract Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] static abstract byte ReadS16BE( @@ -6099,6 +7591,13 @@ static abstract MaybeBool ReadU8( [NativeTypeName("Uint8 *")] Ref value ); + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + static abstract void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + static abstract Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size); + [return: NativeTypeName("Uint32")] [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] static abstract uint RegisterEvents(int numevents); @@ -6110,6 +7609,45 @@ static abstract MaybeBool ReadU8( [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] static abstract void ReleaseCameraFrame(CameraHandle camera, Ref frame); + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUBuffer")] + static abstract void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUComputePipeline")] + static abstract void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUFence")] + static abstract void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] + static abstract void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUSampler")] + static abstract void ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUShader")] + static abstract void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTexture")] + static abstract void ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTransferBuffer")] + static abstract void ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] + static abstract void ReleaseWindowFromGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] @@ -6687,6 +8225,12 @@ static abstract MaybeBool ResumeAudioDevice( [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] static abstract byte ResumeHapticRaw(HapticHandle haptic); + [NativeFunction("SDL3", EntryPoint = "SDL_round")] + static abstract double Round(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_roundf")] + static abstract float Roundf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] @@ -6763,6 +8307,23 @@ static abstract byte RumbleJoystickTriggersRaw( [NativeTypeName("Uint32")] uint duration_ms ); + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + static abstract int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + static abstract int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] @@ -6812,6 +8373,12 @@ static abstract MaybeBool SaveBMPIO( [NativeTypeName("bool")] MaybeBool closeio ); + [NativeFunction("SDL3", EntryPoint = "SDL_scalbn")] + static abstract double Scalbn(double x, int n); + + [NativeFunction("SDL3", EntryPoint = "SDL_scalbnf")] + static abstract float Scalbnf(float x, int n); + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] static abstract Surface* ScaleSurface( Surface* surface, @@ -7183,6 +8750,40 @@ static abstract MaybeBool SetClipboardText( [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] static abstract byte SetCursorRaw(CursorHandle cursor); + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + static abstract int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + static abstract int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + static abstract byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + static abstract MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] static abstract byte SetErrorV( @@ -7313,6 +8914,93 @@ static abstract MaybeBool SetGamepadSensorEnabled( [NativeTypeName("bool")] MaybeBool enabled ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBlendConstants")] + static abstract void SetGPUBlendConstants( + GPURenderPassHandle render_pass, + FColor blend_constants + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + static abstract void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + static abstract void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + static abstract void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + static abstract void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUStencilReference")] + static abstract void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + static abstract MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + static abstract byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + static abstract void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + static abstract void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + static abstract void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + static abstract void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] @@ -7545,6 +9233,28 @@ static abstract MaybeBool SetLogPriorityPrefix( [NativeTypeName("const char *")] Ref prefix ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetMainReady")] + static abstract void SetMainReady(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + static abstract MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + static abstract byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] static abstract void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate); @@ -8500,6 +10210,21 @@ WindowHandle window [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] static abstract void SignalSemaphore(SemaphoreHandle sem); + [NativeFunction("SDL3", EntryPoint = "SDL_sin")] + static abstract double Sin(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sinf")] + static abstract float Sinf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrt")] + static abstract double Sqrt(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrtf")] + static abstract float Sqrtf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_srand")] + static abstract void Srand([NativeTypeName("Uint64")] ulong seed); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] @@ -8524,6 +10249,36 @@ static abstract byte StartTextInputWithPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint props ); + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + static abstract uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + static abstract uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + static abstract uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + static abstract uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] @@ -8569,71 +10324,436 @@ static abstract byte StartTextInputWithPropertiesRaw( [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] static abstract byte StorageReadyRaw(StorageHandle storage); - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] - static abstract Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID); + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + static abstract int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] - static abstract Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID); + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + static abstract int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] - static abstract byte SurfaceHasAlternateImages(Surface* surface); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + static abstract sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] - static abstract MaybeBool SurfaceHasAlternateImages(Ref surface); + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + static abstract Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] - static abstract byte SurfaceHasColorKey(Surface* surface); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + static abstract sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] - static abstract MaybeBool SurfaceHasColorKey(Ref surface); + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + static abstract Ptr Strchr([NativeTypeName("const char *")] Ref str, int c); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] - static abstract byte SurfaceHasRLE(Surface* surface); + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + static abstract int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] - static abstract MaybeBool SurfaceHasRLE(Ref surface); + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + static abstract int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] - static abstract MaybeBool SyncWindow(WindowHandle window); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + static abstract sbyte* Strdup([NativeTypeName("const char *")] sbyte* str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] - static abstract byte SyncWindowRaw(WindowHandle window); + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + static abstract Ptr Strdup([NativeTypeName("const char *")] Ref str); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] - static abstract long TellIO(IOStreamHandle context); + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + static abstract Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] - static abstract MaybeBool TextInputActive(WindowHandle window); + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + static abstract Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] - static abstract byte TextInputActiveRaw(WindowHandle window); + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + static abstract nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ); - [return: NativeTypeName("SDL_Time")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] - static abstract long TimeFromWindows( - [NativeTypeName("Uint32")] uint dwLowDateTime, - [NativeTypeName("Uint32")] uint dwHighDateTime + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + static abstract nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + static abstract nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + static abstract nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + static abstract nuint Strlen([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + static abstract nuint Strlen([NativeTypeName("const char *")] Ref str); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + static abstract sbyte* Strlwr([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + static abstract Ptr Strlwr([NativeTypeName("char *")] Ref str); + + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + static abstract int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + static abstract int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + static abstract int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + static abstract int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + static abstract sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + static abstract Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + static abstract nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + static abstract nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + static abstract sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + static abstract Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + static abstract sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + static abstract Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + static abstract sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + static abstract Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + static abstract sbyte* Strrev([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + static abstract Ptr Strrev([NativeTypeName("char *")] Ref str); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + static abstract sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + static abstract Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + static abstract double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + static abstract double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + static abstract sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + static abstract Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + static abstract nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + static abstract nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + static abstract long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + static abstract long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("unsigned long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + static abstract nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("unsigned long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + static abstract nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("unsigned long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + static abstract ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("unsigned long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + static abstract ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + static abstract sbyte* Strupr([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + static abstract Ptr Strupr([NativeTypeName("char *")] Ref str); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + static abstract MaybeBool SubmitGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence")] + static abstract GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + static abstract byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + static abstract byte SurfaceHasAlternateImages(Surface* surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + static abstract MaybeBool SurfaceHasAlternateImages(Ref surface); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + static abstract byte SurfaceHasColorKey(Surface* surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + static abstract MaybeBool SurfaceHasColorKey(Ref surface); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + static abstract byte SurfaceHasRLE(Surface* surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + static abstract MaybeBool SurfaceHasRLE(Ref surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + static abstract MaybeBool SyncWindow(WindowHandle window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + static abstract byte SyncWindowRaw(WindowHandle window); + + [NativeFunction("SDL3", EntryPoint = "SDL_tan")] + static abstract double Tan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tanf")] + static abstract float Tanf(float x); + + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] + static abstract long TellIO(IOStreamHandle context); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + static abstract MaybeBool TextInputActive(WindowHandle window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + static abstract byte TextInputActiveRaw(WindowHandle window); + + [return: NativeTypeName("SDL_Time")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] + static abstract long TimeFromWindows( + [NativeTypeName("Uint32")] uint dwLowDateTime, + [NativeTypeName("Uint32")] uint dwHighDateTime + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] static abstract byte TimeToDateTime( [NativeTypeName("SDL_Time")] long ticks, DateTime* dt, @@ -8664,6 +10784,18 @@ static abstract void TimeToWindows( [NativeTypeName("Uint32 *")] Ref dwHighDateTime ); + [NativeFunction("SDL3", EntryPoint = "SDL_tolower")] + static abstract int Tolower(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_toupper")] + static abstract int Toupper(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_trunc")] + static abstract double Trunc(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_truncf")] + static abstract float Truncf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] @@ -8711,6 +10843,72 @@ static abstract MaybeBool TryLockSpinlock( [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] static abstract byte TryWaitSemaphoreRaw(SemaphoreHandle sem); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + static abstract sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + static abstract Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + static abstract sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + static abstract Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + static abstract sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + static abstract Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + static abstract sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + static abstract Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] static abstract void UnbindAudioStream(AudioStreamHandle stream); @@ -8766,6 +10964,34 @@ static abstract MaybeBool TryLockSpinlock( [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] static abstract void UnlockTexture(Ref texture); + [NativeFunction("SDL3", EntryPoint = "SDL_UnmapGPUTransferBuffer")] + static abstract void UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + static abstract int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + static abstract int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + static abstract byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + static abstract MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ); + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] static abstract void UpdateGamepads(); @@ -8887,6 +11113,230 @@ static abstract MaybeBool UpdateYUVTexture( int Vpitch ); + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + static abstract void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + static abstract void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + static abstract void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + static abstract void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + static abstract nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + static abstract nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + static abstract nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + static abstract nuint Utf8Strlen([NativeTypeName("const char *")] Ref str); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + static abstract nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + static abstract nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + static abstract int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + static abstract int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + static abstract int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + static abstract int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + static abstract int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + static abstract int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + static abstract int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + static abstract int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + static abstract byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + static abstract MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + static abstract void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + static abstract void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ); + + [return: NativeTypeName("const char *const *")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + static abstract sbyte** VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] uint* count + ); + + [return: NativeTypeName("const char *const *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + static abstract Ptr2D VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] Ref count + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + static abstract byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + static abstract MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ); + + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] + static abstract FunctionPointer VulkanGetVkGetInstanceProcAddr(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + static abstract byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + static abstract MaybeBool VulkanLoadLibrary( + [NativeTypeName("const char *")] Ref path + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_UnloadLibrary")] + static abstract void VulkanUnloadLibrary(); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] static abstract void WaitCondition(ConditionHandle cond, MutexHandle mutex); @@ -8931,6 +11381,51 @@ static abstract MaybeBool WaitEventTimeout( [NativeTypeName("Sint32")] int timeoutMS ); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + static abstract byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + static abstract MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + static abstract MaybeBool WaitForGPUIdle(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + static abstract byte WaitForGPUIdleRaw(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + static abstract byte WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + static abstract MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] static abstract void WaitSemaphore(SemaphoreHandle sem); @@ -8972,6 +11467,178 @@ static abstract byte WaitSemaphoreTimeoutRaw( [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] static abstract uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags); + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + static abstract int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + static abstract int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + static abstract int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + static abstract int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + static abstract uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + static abstract Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + static abstract nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + static abstract nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + static abstract nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + static abstract nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + static abstract nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + static abstract nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + static abstract int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + static abstract int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + static abstract int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + static abstract int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + static abstract nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + static abstract nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + static abstract uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + static abstract Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + static abstract uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + static abstract Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + static abstract nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + static abstract nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] @@ -8981,6 +11648,40 @@ static abstract byte WaitSemaphoreTimeoutRaw( [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] static abstract byte WindowHasSurfaceRaw(WindowHandle window); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + static abstract MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + static abstract byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + static abstract MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + static abstract byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ); + [return: NativeTypeName("size_t")] [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] static abstract nuint WriteIO( @@ -9272,6 +11973,15 @@ static abstract MaybeBool WriteU8( static abstract byte WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value); } + [NativeFunction("SDL3", EntryPoint = "SDL_abs")] + int Abs(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_acos")] + double Acos(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_acosf")] + float Acosf(float x); + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] Surface* AcquireCameraFrame( CameraHandle camera, @@ -9285,6 +11995,30 @@ Ptr AcquireCameraFrame( [NativeTypeName("Uint64 *")] Ref timestampNS ); + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUCommandBuffer")] + GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ); + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] int AddAtomicInt(AtomicInt* a, int v); @@ -9398,67 +12132,381 @@ MaybeBool AddVulkanRenderSemaphores( [NativeTypeName("Sint64")] long signal_semaphore ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] - byte AddVulkanRenderSemaphoresRaw( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + byte AddVulkanRenderSemaphoresRaw( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + void AlignedFree(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + void AlignedFree(Ref mem); + + [NativeFunction("SDL3", EntryPoint = "SDL_asin")] + double Asin(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_asinf")] + float Asinf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan")] + double Atan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2")] + double Atan2(double y, double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2f")] + float Atan2F(float y, float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atanf")] + float Atanf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + double Atof([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + double Atof([NativeTypeName("const char *")] Ref str); + + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + int Atoi([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + int Atoi([NativeTypeName("const char *")] Ref str); + + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + ); + + [return: NativeTypeName("SDL_JoystickID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + MaybeBool AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUCopyPass")] + GPUCopyPassHandle BeginGPUCopyPass(GPUCommandBufferHandle command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + MaybeBool BindAudioStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + byte BindAudioStreamRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + byte BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle* streams, + int num_streams + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + MaybeBool BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref streams, + int num_streams + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputePipeline")] + void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUGraphicsPipeline")] + void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size ); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] - uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings ); - [return: NativeTypeName("SDL_JoystickID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] - uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] - MaybeBool AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] - byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] - MaybeBool BindAudioStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] - byte BindAudioStreamRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] - byte BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle* streams, - int num_streams + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] - MaybeBool BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref streams, - int num_streams + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info ); [return: NativeTypeName("bool")] @@ -9617,6 +12665,71 @@ ScaleMode scaleMode [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] void BroadcastCondition(ConditionHandle cond); + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CalculateGPUTextureFormatSize")] + uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + Ptr Calloc([NativeTypeName("size_t")] nuint nmemb, [NativeTypeName("size_t")] nuint size); + + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + void* CallocRaw([NativeTypeName("size_t")] nuint nmemb, [NativeTypeName("size_t")] nuint size); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + MaybeBool CancelGPUCommandBuffer(GPUCommandBufferHandle command_buffer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] byte CaptureMouse([NativeTypeName("bool")] byte enabled); @@ -9626,6 +12739,21 @@ ScaleMode scaleMode [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] MaybeBool CaptureMouse([NativeTypeName("bool")] MaybeBool enabled); + [NativeFunction("SDL3", EntryPoint = "SDL_ceil")] + double Ceil(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_ceilf")] + float Ceilf(float x); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + MaybeBool ClaimWindowForGPUDevice(GPUDeviceHandle device, WindowHandle window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + byte ClaimWindowForGPUDeviceRaw(GPUDeviceHandle device, WindowHandle window); + [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] void CleanupTLS(); @@ -9906,6 +13034,48 @@ MaybeBool CopyFile( [NativeTypeName("const char *")] Ref newpath ); + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] @@ -9921,6 +13091,12 @@ byte CopyPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint dst ); + [NativeFunction("SDL3", EntryPoint = "SDL_copysign")] + double Copysign(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_copysignf")] + float Copysignf(float x, float y); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] byte CopyStorageFile( @@ -9938,6 +13114,46 @@ MaybeBool CopyStorageFile( [NativeTypeName("const char *")] Ref newpath ); + [NativeFunction("SDL3", EntryPoint = "SDL_cos")] + double Cos(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_cosf")] + float Cosf(float x); + + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint16")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] AudioStreamHandle CreateAudioStream( [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, @@ -9991,6 +13207,128 @@ int hot_y [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] MaybeBool CreateDirectory([NativeTypeName("const char *")] Ref path); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + EnvironmentHandle CreateEnvironment([NativeTypeName("bool")] byte populated); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + EnvironmentHandle CreateEnvironment([NativeTypeName("bool")] MaybeBool populated); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDeviceWithProperties")] + GPUDeviceHandle CreateGPUDeviceWithProperties([NativeTypeName("SDL_PropertiesID")] uint props); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] Ref createinfo + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] int CreateHapticEffect( HapticHandle haptic, @@ -10024,6 +13362,22 @@ WindowHandle CreatePopupWindow( [NativeTypeName("SDL_WindowFlags")] ulong flags ); + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcessWithProperties")] + ProcessHandle CreateProcessWithProperties([NativeTypeName("SDL_PropertiesID")] uint props); + [return: NativeTypeName("SDL_PropertiesID")] [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] uint CreateProperties(); @@ -10252,6 +13606,12 @@ MaybeBool DateTimeToTime( [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] void DestroyCursor(CursorHandle cursor); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyEnvironment")] + void DestroyEnvironment(EnvironmentHandle env); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyGPUDevice")] + void DestroyGPUDevice(GPUDeviceHandle device); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] void DestroyHapticEffect(HapticHandle haptic, int effect); @@ -10265,6 +13625,9 @@ MaybeBool DateTimeToTime( [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] void DestroyPalette(Ref palette); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProcess")] + void DestroyProcess(ProcessHandle process); + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props); @@ -10324,6 +13687,89 @@ MaybeBool DateTimeToTime( [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] byte DisableScreenSaverRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUCompute")] + void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUComputeIndirect")] + void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] + void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] + void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] + void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* destination + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] + void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitives")] + void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect")] + void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitives")] + void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] + void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] Surface* DuplicateSurface(Surface* surface); @@ -10395,6 +13841,36 @@ Ref userdata [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] byte EnableScreenSaverRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUComputePass")] + void EndGPUComputePass(GPUComputePassHandle compute_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUCopyPass")] + void EndGPUCopyPass(GPUCopyPassHandle copy_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPURenderPass")] + void EndGPURenderPass(GPURenderPassHandle render_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] byte EnumerateDirectory( @@ -10457,6 +13933,15 @@ Ref userdata [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] byte EventEnabledRaw([NativeTypeName("Uint32")] uint type); + [NativeFunction("SDL3", EntryPoint = "SDL_exp")] + double Exp(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_expf")] + float Expf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_fabs")] + double Fabs(double x); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] byte FillSurfaceRect( @@ -10518,6 +14003,12 @@ MaybeBool FillSurfaceRects( [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] MaybeBool FlipSurface(Ref surface, FlipMode flip); + [NativeFunction("SDL3", EntryPoint = "SDL_floor")] + double Floor(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_floorf")] + float Floorf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] @@ -10554,6 +14045,19 @@ void FlushEvents( [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] byte FlushRendererRaw(RendererHandle renderer); + [NativeFunction("SDL3", EntryPoint = "SDL_fmod")] + double Fmod(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_fmodf")] + float Fmodf(float x, float y); + + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + void Free(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + void Free(Ref mem); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] @@ -10608,6 +14112,12 @@ void FlushEvents( [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type); + [NativeFunction("SDL3", EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] + void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ); + [return: NativeTypeName("const char *")] [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name); @@ -11108,6 +14618,51 @@ MaybeBool GetDisplayUsableBounds( Ref rect ); + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] + sbyte* Getenv([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] + Ptr Getenv([NativeTypeName("const char *")] Ref name); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] + sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] + Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironment")] + EnvironmentHandle GetEnvironment(); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] + sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] + Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ); + + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + Ptr2D GetEnvironmentVariables(EnvironmentHandle env); + + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env); + [return: NativeTypeName("const char *")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] @@ -11459,14 +15014,39 @@ Ref pressure [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] uint GetGlobalMouseState(float* x, float* y); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] - uint GetGlobalMouseState(Ref x, Ref y); + [return: NativeTypeName("SDL_MouseButtonFlags")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + uint GetGlobalMouseState(Ref x, Ref y); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] + uint GetGlobalProperties(); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] + Ptr GetGPUDeviceDriver(GPUDeviceHandle device); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] + sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] + Ptr GetGPUDriver(int index); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] + sbyte* GetGPUDriverRaw(int index); + + [return: NativeTypeName("SDL_GPUShaderFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUShaderFormats")] + uint GetGPUShaderFormats(GPUDeviceHandle device); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] - uint GetGlobalProperties(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] + GPUTextureFormat GetGPUSwapchainTextureFormat(GPUDeviceHandle device, WindowHandle window); [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] WindowHandle GetGrabbedWindow(); @@ -11849,6 +15429,23 @@ MaybeBool GetMasksForPixelFormat( [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] int GetMaxHapticEffectsPlaying(HapticHandle haptic); + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ); + [return: NativeTypeName("SDL_MouseID *")] [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] uint* GetMice(int* count); @@ -11888,6 +15485,9 @@ DisplayOrientation GetNaturalDisplayOrientation( [NativeTypeName("SDL_DisplayID")] uint displayID ); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAllocations")] + int GetNumAllocations(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] int GetNumAudioDrivers(); @@ -11917,6 +15517,9 @@ long GetNumberProperty( [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] int GetNumGamepadTouchpads(GamepadHandle gamepad); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGPUDrivers")] + int GetNumGPUDrivers(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] int GetNumHapticAxes(HapticHandle haptic); @@ -11941,6 +15544,23 @@ long GetNumberProperty( [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] int GetNumVideoDrivers(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] byte GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info); @@ -12054,6 +15674,16 @@ Ptr GetPrefPath( [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] sbyte* GetPrimarySelectionTextRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessInput")] + IOStreamHandle GetProcessInput(ProcessHandle process); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessOutput")] + IOStreamHandle GetProcessOutput(ProcessHandle process); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessProperties")] + uint GetProcessProperties(ProcessHandle process); + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] PropertyType GetPropertyType( [NativeTypeName("SDL_PropertiesID")] uint props, @@ -13281,6 +16911,70 @@ Ptr2D GlobStorageDirectory( Ref count ); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] + MaybeBool GPUSupportsProperties([NativeTypeName("SDL_PropertiesID")] uint props); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] + byte GPUSupportsPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] + byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] + MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] + uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] + MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] + byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ); + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] void GuidToString(Guid guid, [NativeTypeName("char *")] sbyte* pszGUID, int cbGUID); @@ -13838,6 +17532,64 @@ int HidWrite( [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] byte HideWindowRaw(WindowHandle window); + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_close")] + int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd); + + [return: NativeTypeName("SDL_iconv_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ); + + [return: NativeTypeName("SDL_iconv_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] + sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] + Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Init")] @@ -13865,6 +17617,19 @@ int HidWrite( [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags); + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ); + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] IOStreamHandle IOFromConstMem( [NativeTypeName("const void *")] void* mem, @@ -13918,6 +17683,21 @@ nuint IOvprintf( [NativeTypeName("va_list")] Ref ap ); + [NativeFunction("SDL3", EntryPoint = "SDL_isalnum")] + int Isalnum(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isalpha")] + int Isalpha(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isblank")] + int Isblank(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_iscntrl")] + int Iscntrl(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isdigit")] + int Isdigit(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] @@ -13927,6 +17707,15 @@ nuint IOvprintf( [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id); + [NativeFunction("SDL3", EntryPoint = "SDL_isgraph")] + int Isgraph(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isinf")] + int Isinf(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isinff")] + int Isinff(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] @@ -13945,6 +17734,9 @@ nuint IOvprintf( [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] byte IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id); + [NativeFunction("SDL3", EntryPoint = "SDL_islower")] + int Islower(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] @@ -13954,6 +17746,21 @@ nuint IOvprintf( [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] byte IsMouseHapticRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_isnan")] + int Isnan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isnanf")] + int Isnanf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isprint")] + int Isprint(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_ispunct")] + int Ispunct(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isspace")] + int Isspace(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] @@ -13972,6 +17779,21 @@ nuint IOvprintf( [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] byte IsTVRaw(); + [NativeFunction("SDL3", EntryPoint = "SDL_isupper")] + int Isupper(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isxdigit")] + int Isxdigit(int x); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + sbyte* Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + Ptr Itoa(int value, [NativeTypeName("char *")] Ref str, int radix); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] @@ -13990,6 +17812,35 @@ nuint IOvprintf( [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] byte JoystickEventsEnabledRaw(); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + byte KillProcess(ProcessHandle process, [NativeTypeName("bool")] byte force); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file); @@ -14176,6 +18027,18 @@ MaybeBool LockTextureToSurface( Ref2D surface ); + [NativeFunction("SDL3", EntryPoint = "SDL_log")] + double Log(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_log10")] + double Log10(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_log10f")] + float Log10F(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_logf")] + float Logf(float x); + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] void LogMessageV( int category, @@ -14193,6 +18056,60 @@ void LogMessageV( [NativeTypeName("va_list")] Ref ap ); + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lround")] + nint Lround(double x); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lroundf")] + nint Lroundf(float x); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + Ptr Malloc([NativeTypeName("size_t")] nuint size); + + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + void* MallocRaw([NativeTypeName("size_t")] nuint size); + + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ); + [return: NativeTypeName("Uint32")] [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] uint MapRGB( @@ -14286,12 +18203,42 @@ uint MapSurfaceRgba( [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] byte MaximizeWindowRaw(WindowHandle window); + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ); + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] void MemoryBarrierAcquireFunction(); [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] void MemoryBarrierReleaseFunction(); + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ); + [return: NativeTypeName("SDL_MetalView")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] @@ -14345,6 +18292,37 @@ MaybeBool MixAudio( float volume ); + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + double Modf(double x, double* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + double Modf(double x, Ref y); + + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + float Modff(float x, float* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + float Modff(float x, Ref y); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ); + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] void OnApplicationDidEnterBackground(); @@ -14577,6 +18555,15 @@ byte PlayHapticRumbleRaw( [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] MaybeBool PollEvent(Ref @event); + [NativeFunction("SDL3", EntryPoint = "SDL_PopGPUDebugGroup")] + void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_pow")] + double Pow(double x, double y); + + [NativeFunction("SDL3", EntryPoint = "SDL_powf")] + float Powf(float x, float y); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] byte PremultiplyAlpha( @@ -14630,6 +18617,70 @@ MaybeBool PremultiplySurfaceAlpha( [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] MaybeBool PushEvent(Ref @event); + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] byte PutAudioStreamData( @@ -14647,6 +18698,51 @@ MaybeBool PutAudioStreamData( int len ); + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence); + [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] void Quit(); @@ -14662,6 +18758,42 @@ int len [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] byte RaiseWindowRaw(WindowHandle window); + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand")] + int Rand([NativeTypeName("Sint32")] int n); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits")] + uint RandBits(); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + uint RandBitsR([NativeTypeName("Uint64 *")] Ref state); + + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + int RandR([NativeTypeName("Uint64 *")] ulong* state, [NativeTypeName("Sint32")] int n); + + [return: NativeTypeName("Sint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + int RandR([NativeTypeName("Uint64 *")] Ref state, [NativeTypeName("Sint32")] int n); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf")] + float Randf(); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + float RandfR([NativeTypeName("Uint64 *")] ulong* state); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + float RandfR([NativeTypeName("Uint64 *")] Ref state); + [return: NativeTypeName("size_t")] [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] nuint ReadIO(IOStreamHandle context, void* ptr, [NativeTypeName("size_t")] nuint size); @@ -14671,6 +18803,21 @@ int len [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] nuint ReadIO(IOStreamHandle context, Ref ptr, [NativeTypeName("size_t")] nuint size); + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] byte ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value); @@ -14866,16 +19013,56 @@ Ref a [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] MaybeBool ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] Ref value); + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size); + [return: NativeTypeName("Uint32")] [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] uint RegisterEvents(int numevents); - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] - void ReleaseCameraFrame(CameraHandle camera, Surface* frame); + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + void ReleaseCameraFrame(CameraHandle camera, Surface* frame); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + void ReleaseCameraFrame(CameraHandle camera, Ref frame); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUBuffer")] + void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUComputePipeline")] + void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUFence")] + void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] + void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUSampler")] + void ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUShader")] + void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] - void ReleaseCameraFrame(CameraHandle camera, Ref frame); + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTexture")] + void ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTransferBuffer")] + void ReleaseGPUTransferBuffer(GPUDeviceHandle device, GPUTransferBufferHandle transfer_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] + void ReleaseWindowFromGPUDevice(GPUDeviceHandle device, WindowHandle window); [return: NativeTypeName("bool")] [Transformed] @@ -15423,6 +19610,12 @@ int line [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] byte ResumeHapticRaw(HapticHandle haptic); + [NativeFunction("SDL3", EntryPoint = "SDL_round")] + double Round(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_roundf")] + float Roundf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] @@ -15499,6 +19692,23 @@ byte RumbleJoystickTriggersRaw( [NativeTypeName("Uint32")] uint duration_ms ); + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] @@ -15538,6 +19748,12 @@ MaybeBool SaveBMPIO( [NativeTypeName("bool")] MaybeBool closeio ); + [NativeFunction("SDL3", EntryPoint = "SDL_scalbn")] + double Scalbn(double x, int n); + + [NativeFunction("SDL3", EntryPoint = "SDL_scalbnf")] + float Scalbnf(float x, int n); + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] Surface* ScaleSurface(Surface* surface, int width, int height, ScaleMode scaleMode); @@ -15887,6 +20103,40 @@ MaybeBool SetClipboardData( [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] byte SetCursorRaw(CursorHandle cursor); + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] byte SetErrorV( @@ -16006,6 +20256,90 @@ MaybeBool SetGamepadSensorEnabled( [NativeTypeName("bool")] MaybeBool enabled ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBlendConstants")] + void SetGPUBlendConstants(GPURenderPassHandle render_pass, FColor blend_constants); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUStencilReference")] + void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] @@ -16224,6 +20558,28 @@ MaybeBool SetLogPriorityPrefix( [NativeTypeName("const char *")] Ref prefix ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetMainReady")] + void SetMainReady(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ); + [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate); @@ -17083,6 +21439,21 @@ WindowHandle window [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] void SignalSemaphore(SemaphoreHandle sem); + [NativeFunction("SDL3", EntryPoint = "SDL_sin")] + double Sin(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sinf")] + float Sinf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrt")] + double Sqrt(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrtf")] + float Sqrtf(float x); + + [NativeFunction("SDL3", EntryPoint = "SDL_srand")] + void Srand([NativeTypeName("Uint64")] ulong seed); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] @@ -17107,6 +21478,36 @@ byte StartTextInputWithPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint props ); + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] @@ -17152,6 +21553,65 @@ byte StartTextInputWithPropertiesRaw( [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] byte StorageReadyRaw(StorageHandle storage); + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + Ptr Strchr([NativeTypeName("const char *")] Ref str, int c); + + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + sbyte* Strdup([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + Ptr Strdup([NativeTypeName("const char *")] Ref str); + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID); @@ -17159,6 +21619,302 @@ byte StartTextInputWithPropertiesRaw( [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID); + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + nuint Strlen([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + nuint Strlen([NativeTypeName("const char *")] Ref str); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + sbyte* Strlwr([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + Ptr Strlwr([NativeTypeName("char *")] Ref str); + + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + sbyte* Strrev([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + Ptr Strrev([NativeTypeName("char *")] Ref str); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("unsigned long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("unsigned long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("unsigned long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); + + [return: NativeTypeName("unsigned long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + sbyte* Strupr([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + Ptr Strupr([NativeTypeName("char *")] Ref str); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + MaybeBool SubmitGPUCommandBuffer(GPUCommandBufferHandle command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence")] + GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence(GPUCommandBufferHandle command_buffer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); + [return: NativeTypeName("bool")] [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] byte SurfaceHasAlternateImages(Surface* surface); @@ -17195,6 +21951,12 @@ byte StartTextInputWithPropertiesRaw( [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] byte SyncWindowRaw(WindowHandle window); + [NativeFunction("SDL3", EntryPoint = "SDL_tan")] + double Tan(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tanf")] + float Tanf(float x); + [return: NativeTypeName("Sint64")] [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] long TellIO(IOStreamHandle context); @@ -17247,6 +22009,18 @@ void TimeToWindows( [NativeTypeName("Uint32 *")] Ref dwHighDateTime ); + [NativeFunction("SDL3", EntryPoint = "SDL_tolower")] + int Tolower(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_toupper")] + int Toupper(int x); + + [NativeFunction("SDL3", EntryPoint = "SDL_trunc")] + double Trunc(double x); + + [NativeFunction("SDL3", EntryPoint = "SDL_truncf")] + float Truncf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] @@ -17292,6 +22066,72 @@ void TimeToWindows( [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] byte TryWaitSemaphoreRaw(SemaphoreHandle sem); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ); + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] void UnbindAudioStream(AudioStreamHandle stream); @@ -17347,6 +22187,31 @@ void TimeToWindows( [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] void UnlockTexture(Ref texture); + [NativeFunction("SDL3", EntryPoint = "SDL_UnmapGPUTransferBuffer")] + void UnmapGPUTransferBuffer(GPUDeviceHandle device, GPUTransferBufferHandle transfer_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ); + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] void UpdateGamepads(); @@ -17468,6 +22333,222 @@ MaybeBool UpdateYUVTexture( int Vpitch ); + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + nuint Utf8Strlen([NativeTypeName("const char *")] Ref str); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ); + + [return: NativeTypeName("const char *const *")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + sbyte** VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] uint* count); + + [return: NativeTypeName("const char *const *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + Ptr2D VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] Ref count); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ); + + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] + FunctionPointer VulkanGetVkGetInstanceProcAddr(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + MaybeBool VulkanLoadLibrary([NativeTypeName("const char *")] Ref path); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_UnloadLibrary")] + void VulkanUnloadLibrary(); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] void WaitCondition(ConditionHandle cond, MutexHandle mutex); @@ -17506,6 +22587,47 @@ byte WaitConditionTimeoutRaw( [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] MaybeBool WaitEventTimeout(Ref @event, [NativeTypeName("Sint32")] int timeoutMS); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + MaybeBool WaitForGPUIdle(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + byte WaitForGPUIdleRaw(GPUDeviceHandle device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + byte WaitProcess(ProcessHandle process, [NativeTypeName("bool")] byte block, int* exitcode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] void WaitSemaphore(SemaphoreHandle sem); @@ -17544,6 +22666,178 @@ MaybeBool WaitSemaphoreTimeout( [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags); + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] @@ -17553,6 +22847,40 @@ MaybeBool WaitSemaphoreTimeout( [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] byte WindowHasSurfaceRaw(WindowHandle window); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ); + [return: NativeTypeName("size_t")] [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] nuint WriteIO( diff --git a/sources/SDL/SDL/SDL3/MainFunc.gen.cs b/sources/SDL/SDL/SDL3/MainFunc.gen.cs new file mode 100644 index 0000000000..b1dfd3a115 --- /dev/null +++ b/sources/SDL/SDL/SDL3/MainFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct MainFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public MainFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public MainFunc(MainFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator MainFunc(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(MainFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/MainFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/MainFuncDelegate.gen.cs new file mode 100644 index 0000000000..ba3a2fcae3 --- /dev/null +++ b/sources/SDL/SDL/SDL3/MainFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate int MainFuncDelegate(int arg0, sbyte** arg1); diff --git a/sources/SDL/SDL/SDL3/MallocFunc.gen.cs b/sources/SDL/SDL/SDL3/MallocFunc.gen.cs new file mode 100644 index 0000000000..d25b8977f0 --- /dev/null +++ b/sources/SDL/SDL/SDL3/MallocFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct MallocFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => (delegate* unmanaged)Pointer; + + public MallocFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public MallocFunc(MallocFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator MallocFunc(delegate* unmanaged pfn) => new(pfn); + + public static implicit operator delegate* unmanaged(MallocFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/MallocFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/MallocFuncDelegate.gen.cs new file mode 100644 index 0000000000..8f1491d9b4 --- /dev/null +++ b/sources/SDL/SDL/SDL3/MallocFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate void* MallocFuncDelegate(nuint arg0); diff --git a/sources/SDL/SDL/SDL3/ProcessIO.gen.cs b/sources/SDL/SDL/SDL3/ProcessIO.gen.cs new file mode 100644 index 0000000000..400b2e7668 --- /dev/null +++ b/sources/SDL/SDL/SDL3/ProcessIO.gen.cs @@ -0,0 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +[NativeTypeName("unsigned int")] +public enum ProcessIO : uint +{ + Inherited, + Null, + App, + Redirect, +} diff --git a/sources/SDL/SDL/SDL3/ReallocFunc.gen.cs b/sources/SDL/SDL/SDL3/ReallocFunc.gen.cs new file mode 100644 index 0000000000..6c40b01b61 --- /dev/null +++ b/sources/SDL/SDL/SDL3/ReallocFunc.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public readonly unsafe struct ReallocFunc : IDisposable +{ + private readonly void* Pointer; + public delegate* unmanaged Handle => + (delegate* unmanaged)Pointer; + + public ReallocFunc(delegate* unmanaged ptr) => Pointer = ptr; + + public ReallocFunc(ReallocFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc); + + public void Dispose() => SilkMarshal.Free(Pointer); + + public static implicit operator ReallocFunc(delegate* unmanaged pfn) => + new(pfn); + + public static implicit operator delegate* unmanaged(ReallocFunc pfn) => + (delegate* unmanaged)pfn.Pointer; +} diff --git a/sources/SDL/SDL/SDL3/ReallocFuncDelegate.gen.cs b/sources/SDL/SDL/SDL3/ReallocFuncDelegate.gen.cs new file mode 100644 index 0000000000..c4e77edc33 --- /dev/null +++ b/sources/SDL/SDL/SDL3/ReallocFuncDelegate.gen.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Silk.NET.SDL; + +public unsafe delegate void* ReallocFuncDelegate(void* arg0, nuint arg1); diff --git a/sources/SDL/SDL/SDL3/Sdl.gen.cs b/sources/SDL/SDL/SDL3/Sdl.gen.cs index 51d200e283..c9a13b8573 100644 --- a/sources/SDL/SDL/SDL3/Sdl.gen.cs +++ b/sources/SDL/SDL/SDL3/Sdl.gen.cs @@ -12,6 +12,15 @@ public unsafe partial class Sdl : ISdl, ISdl.Static { public partial class DllImport : ISdl.Static { + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_abs")] + public static extern int Abs(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_acos")] + public static extern double Acos(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_acosf")] + public static extern float Acosf(float x); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_AcquireCameraFrame")] public static extern Surface* AcquireCameraFrame( CameraHandle camera, @@ -34,6 +43,48 @@ public static Ptr AcquireCameraFrame( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_AcquireGPUCommandBuffer")] + public static extern GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + [return: NativeTypeName("bool")] + public static extern byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ) + { + fixed (uint* __dsl_swapchain_texture_height = swapchain_texture_height) + fixed (uint* __dsl_swapchain_texture_width = swapchain_texture_width) + fixed (GPUTextureHandle* __dsl_swapchain_texture = swapchain_texture) + { + return (MaybeBool) + (byte)AcquireGPUSwapchainTexture( + command_buffer, + window, + __dsl_swapchain_texture, + __dsl_swapchain_texture_width, + __dsl_swapchain_texture_height + ); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_AddAtomicInt")] public static extern int AddAtomicInt(AtomicInt* a, int v); @@ -250,6 +301,88 @@ public static extern byte AddVulkanRenderSemaphoresRaw( [NativeTypeName("Sint64")] long signal_semaphore ); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => (void*)AlignedAllocRaw(alignment, size); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_aligned_alloc")] + public static extern void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_aligned_free")] + public static extern void AlignedFree(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void AlignedFree(Ref mem) + { + fixed (void* __dsl_mem = mem) + { + AlignedFree(__dsl_mem); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_asin")] + public static extern double Asin(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_asinf")] + public static extern float Asinf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atan")] + public static extern double Atan(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atan2")] + public static extern double Atan2(double y, double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atan2f")] + public static extern float Atan2F(float y, float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atanf")] + public static extern float Atanf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atof")] + public static extern double Atof([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Atof([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (double)Atof(__dsl_str); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_atoi")] + public static extern int Atoi([NativeTypeName("const char *")] sbyte* str); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Atoi([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (int)Atoi(__dsl_str); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_AttachVirtualJoystick")] [return: NativeTypeName("SDL_JoystickID")] public static extern uint AttachVirtualJoystick( @@ -285,6 +418,95 @@ public static extern byte AudioDevicePausedRaw( [NativeTypeName("SDL_AudioDeviceID")] uint dev ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BeginGPUComputePass")] + public static extern GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) + { + fixed ( + GPUStorageBufferReadWriteBinding* __dsl_storage_buffer_bindings = + storage_buffer_bindings + ) + fixed ( + GPUStorageTextureReadWriteBinding* __dsl_storage_texture_bindings = + storage_texture_bindings + ) + { + return (GPUComputePassHandle)BeginGPUComputePass( + command_buffer, + __dsl_storage_texture_bindings, + num_storage_texture_bindings, + __dsl_storage_buffer_bindings, + num_storage_buffer_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BeginGPUCopyPass")] + public static extern GPUCopyPassHandle BeginGPUCopyPass( + GPUCommandBufferHandle command_buffer + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BeginGPURenderPass")] + public static extern GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ) + { + fixed ( + GPUDepthStencilTargetInfo* __dsl_depth_stencil_target_info = + depth_stencil_target_info + ) + fixed (GPUColorTargetInfo* __dsl_color_target_infos = color_target_infos) + { + return (GPURenderPassHandle)BeginGPURenderPass( + command_buffer, + __dsl_color_target_infos, + num_color_targets, + __dsl_depth_stencil_target_info + ); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] @@ -326,6 +548,381 @@ int num_streams } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUComputePipeline")] + public static extern void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUComputeSamplers")] + public static extern void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) + { + BindGPUComputeSamplers( + compute_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + public static extern void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUComputeStorageTextures")] + public static extern void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + BindGPUComputeStorageTextures( + compute_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUFragmentSamplers")] + public static extern void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) + { + BindGPUFragmentSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + public static extern void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + public static extern void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + BindGPUFragmentStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUGraphicsPipeline")] + public static extern void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUIndexBuffer")] + public static extern void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ) + { + fixed (GPUBufferBinding* __dsl_binding = binding) + { + BindGPUIndexBuffer(render_pass, __dsl_binding, index_element_size); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUVertexBuffers")] + public static extern void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferBinding* __dsl_bindings = bindings) + { + BindGPUVertexBuffers(render_pass, first_slot, __dsl_bindings, num_bindings); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUVertexSamplers")] + public static extern void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) + { + BindGPUVertexSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + public static extern void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + BindGPUVertexStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BindGPUVertexStorageTextures")] + public static extern void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + BindGPUVertexStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BlitGPUTexture")] + public static extern void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info + ) + { + fixed (GPUBlitInfo* __dsl_info = info) + { + BlitGPUTexture(command_buffer, __dsl_info); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BlitSurface")] [return: NativeTypeName("bool")] public static extern byte BlitSurface( @@ -603,6 +1200,103 @@ ScaleMode scaleMode [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_BroadcastCondition")] public static extern void BroadcastCondition(ConditionHandle cond); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_bsearch")] + public static extern void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) + { + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) + { + return (void*)Bsearch(__dsl_key, __dsl_base, nmemb, size, compare); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_bsearch_r")] + public static extern void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) + { + return (void*)BsearchR(__dsl_key, __dsl_base, nmemb, size, compare, __dsl_userdata); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CalculateGPUTextureFormatSize")] + [return: NativeTypeName("Uint32")] + public static extern uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => (void*)CallocRaw(nmemb, size); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_calloc")] + public static extern void* CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + public static MaybeBool CancelGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ) => (MaybeBool)(byte)CancelGPUCommandBufferRaw(command_buffer); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CancelGPUCommandBuffer")] + [return: NativeTypeName("bool")] + public static extern byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CaptureMouse")] [return: NativeTypeName("bool")] public static extern byte CaptureMouse([NativeTypeName("bool")] byte enabled); @@ -614,6 +1308,27 @@ public static MaybeBool CaptureMouse( [NativeTypeName("bool")] MaybeBool enabled ) => (MaybeBool)(byte)CaptureMouse((byte)enabled); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ceil")] + public static extern double Ceil(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ceilf")] + public static extern float Ceilf(float x); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + public static MaybeBool ClaimWindowForGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ) => (MaybeBool)(byte)ClaimWindowForGPUDeviceRaw(device, window); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ClaimWindowForGPUDevice")] + [return: NativeTypeName("bool")] + public static extern byte ClaimWindowForGPUDeviceRaw( + GPUDeviceHandle device, + WindowHandle window + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CleanupTLS")] public static extern void CleanupTLS(); @@ -1085,6 +1800,82 @@ public static MaybeBool CopyFile( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CopyGPUBufferToBuffer")] + public static extern void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUBufferLocation* __dsl_destination = destination) + fixed (GPUBufferLocation* __dsl_source = source) + { + CopyGPUBufferToBuffer( + copy_pass, + __dsl_source, + __dsl_destination, + size, + (byte)cycle + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CopyGPUTextureToTexture")] + public static extern void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUTextureLocation* __dsl_destination = destination) + fixed (GPUTextureLocation* __dsl_source = source) + { + CopyGPUTextureToTexture( + copy_pass, + __dsl_source, + __dsl_destination, + w, + h, + d, + (byte)cycle + ); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] @@ -1100,6 +1891,12 @@ public static extern byte CopyPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint dst ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_copysign")] + public static extern double Copysign(double x, double y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_copysignf")] + public static extern float Copysignf(float x, float y); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CopyStorageFile")] [return: NativeTypeName("bool")] public static extern byte CopyStorageFile( @@ -1128,6 +1925,64 @@ public static MaybeBool CopyStorageFile( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_cos")] + public static extern double Cos(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_cosf")] + public static extern float Cosf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_crc16")] + [return: NativeTypeName("Uint16")] + public static extern ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint16")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_data = data) + { + return (ushort)Crc16(crc, __dsl_data, len); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_crc32")] + [return: NativeTypeName("Uint32")] + public static extern uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_data = data) + { + return (uint)Crc32(crc, __dsl_data, len); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateAudioStream")] public static extern AudioStreamHandle CreateAudioStream( [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, @@ -1221,6 +2076,211 @@ public static MaybeBool CreateDirectory( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateEnvironment")] + public static extern EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] byte populated + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + public static EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] MaybeBool populated + ) => (EnvironmentHandle)CreateEnvironment((byte)populated); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUBuffer")] + public static extern GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ) + { + fixed (GPUBufferCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUBufferHandle)CreateGPUBuffer(device, __dsl_createinfo); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUComputePipeline")] + public static extern GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUComputePipelineCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUComputePipelineHandle)CreateGPUComputePipeline(device, __dsl_createinfo); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUDevice")] + public static extern GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (GPUDeviceHandle)CreateGPUDevice(format_flags, (byte)debug_mode, __dsl_name); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUDeviceWithProperties")] + public static extern GPUDeviceHandle CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + public static extern GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUGraphicsPipelineCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUGraphicsPipelineHandle)CreateGPUGraphicsPipeline( + device, + __dsl_createinfo + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUSampler")] + public static extern GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUSamplerCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUSamplerHandle)CreateGPUSampler(device, __dsl_createinfo); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUShader")] + public static extern GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ) + { + fixed (GPUShaderCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUShaderHandle)CreateGPUShader(device, __dsl_createinfo); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUTexture")] + public static extern GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUTextureCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUTextureHandle)CreateGPUTexture(device, __dsl_createinfo); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateGPUTransferBuffer")] + public static extern GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUTransferBufferCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUTransferBufferHandle)CreateGPUTransferBuffer(device, __dsl_createinfo); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateHapticEffect")] public static extern int CreateHapticEffect( HapticHandle haptic, @@ -1267,6 +2327,33 @@ public static extern WindowHandle CreatePopupWindow( [NativeTypeName("SDL_WindowFlags")] ulong flags ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateProcess")] + public static extern ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ) + { + fixed (sbyte** __dsl_args = args) + { + return (ProcessHandle)CreateProcess(__dsl_args, (byte)pipe_stdio); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateProcessWithProperties")] + public static extern ProcessHandle CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_CreateProperties")] [return: NativeTypeName("SDL_PropertiesID")] public static extern uint CreateProperties(); @@ -1635,6 +2722,12 @@ public static MaybeBool DateTimeToTime( [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyCursor")] public static extern void DestroyCursor(CursorHandle cursor); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyEnvironment")] + public static extern void DestroyEnvironment(EnvironmentHandle env); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyGPUDevice")] + public static extern void DestroyGPUDevice(GPUDeviceHandle device); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyHapticEffect")] public static extern void DestroyHapticEffect(HapticHandle haptic, int effect); @@ -1657,6 +2750,9 @@ public static void DestroyPalette(Ref palette) } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyProcess")] + public static extern void DestroyProcess(ProcessHandle process); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DestroyProperties")] public static extern void DestroyProperties( [NativeTypeName("SDL_PropertiesID")] uint props @@ -1742,6 +2838,114 @@ public static MaybeBool DisableScreenSaver() => [return: NativeTypeName("bool")] public static extern byte DisableScreenSaverRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DispatchGPUCompute")] + public static extern void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DispatchGPUComputeIndirect")] + public static extern void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DownloadFromGPUBuffer")] + public static extern void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination + ) + { + fixed (GPUTransferBufferLocation* __dsl_destination = destination) + fixed (GPUBufferRegion* __dsl_source = source) + { + DownloadFromGPUBuffer(copy_pass, __dsl_source, __dsl_destination); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DownloadFromGPUTexture")] + public static extern void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + GPUTextureTransferInfo* destination + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination + ) + { + fixed (GPUTextureTransferInfo* __dsl_destination = destination) + fixed (GPUTextureRegion* __dsl_source = source) + { + DownloadFromGPUTexture(copy_pass, __dsl_source, __dsl_destination); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DrawGPUIndexedPrimitives")] + public static extern void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ); + + [DllImport( + "SDL3", + ExactSpelling = true, + EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect" + )] + public static extern void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DrawGPUPrimitives")] + public static extern void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] + public static extern void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_DuplicateSurface")] public static extern Surface* DuplicateSurface(Surface* surface); @@ -1860,6 +3064,52 @@ public static MaybeBool EnableScreenSaver() => [return: NativeTypeName("bool")] public static extern byte EnableScreenSaverRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_EndGPUComputePass")] + public static extern void EndGPUComputePass(GPUComputePassHandle compute_pass); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_EndGPUCopyPass")] + public static extern void EndGPUCopyPass(GPUCopyPassHandle copy_pass); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_EndGPURenderPass")] + public static extern void EndGPURenderPass(GPURenderPassHandle render_pass); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_EnterAppMainCallbacks")] + public static extern int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) + { + fixed (sbyte** __dsl_argv = argv) + { + return (int)EnterAppMainCallbacks( + argc, + __dsl_argv, + appinit, + appiter, + appevent, + appquit + ); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_EnumerateDirectory")] [return: NativeTypeName("bool")] public static extern byte EnumerateDirectory( @@ -1956,6 +3206,15 @@ public static MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) [return: NativeTypeName("bool")] public static extern byte EventEnabledRaw([NativeTypeName("Uint32")] uint type); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_exp")] + public static extern double Exp(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_expf")] + public static extern float Expf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_fabs")] + public static extern double Fabs(double x); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_FillSurfaceRect")] [return: NativeTypeName("bool")] public static extern byte FillSurfaceRect( @@ -2063,6 +3322,12 @@ public static MaybeBool FlipSurface(Ref surface, FlipMode flip) } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_floor")] + public static extern double Floor(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_floorf")] + public static extern float Floorf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] @@ -2102,6 +3367,28 @@ public static MaybeBool FlushRenderer(RendererHandle renderer) => [return: NativeTypeName("bool")] public static extern byte FlushRendererRaw(RendererHandle renderer); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_fmod")] + public static extern double Fmod(double x, double y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_fmodf")] + public static extern float Fmodf(float x, float y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_free")] + public static extern void Free(void* mem); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Free(Ref mem) + { + fixed (void* __dsl_mem = mem) + { + Free(__dsl_mem); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] @@ -2166,6 +3453,12 @@ SensorType type [return: NativeTypeName("bool")] public static extern byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] + public static extern void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetAppMetadataProperty")] [return: NativeTypeName("const char *")] public static extern sbyte* GetAppMetadataProperty( @@ -3062,6 +4355,82 @@ Ref rect } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_getenv")] + [return: NativeTypeName("const char *")] + public static extern sbyte* Getenv([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Getenv([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)Getenv(__dsl_name); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_getenv_unsafe")] + [return: NativeTypeName("const char *")] + public static extern sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)GetenvUnsafe(__dsl_name); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetEnvironment")] + public static extern EnvironmentHandle GetEnvironment(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetEnvironmentVariable")] + [return: NativeTypeName("const char *")] + public static extern sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)GetEnvironmentVariable(env, __dsl_name); + } + } + + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr2D GetEnvironmentVariables(EnvironmentHandle env) => + (sbyte**)GetEnvironmentVariablesRaw(env); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetEnvironmentVariables")] + [return: NativeTypeName("char **")] + public static extern sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env); + [return: NativeTypeName("const char *")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] @@ -3684,6 +5053,41 @@ public static uint GetGlobalMouseState(Ref x, Ref y) [return: NativeTypeName("SDL_PropertiesID")] public static extern uint GetGlobalProperties(); + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr GetGPUDeviceDriver(GPUDeviceHandle device) => + (sbyte*)GetGPUDeviceDriverRaw(device); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetGPUDeviceDriver")] + [return: NativeTypeName("const char *")] + public static extern sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr GetGPUDriver(int index) => (sbyte*)GetGPUDriverRaw(index); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetGPUDriver")] + [return: NativeTypeName("const char *")] + public static extern sbyte* GetGPUDriverRaw(int index); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetGPUShaderFormats")] + [return: NativeTypeName("SDL_GPUShaderFormat")] + public static extern uint GetGPUShaderFormats(GPUDeviceHandle device); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] + public static extern GPUTextureFormat GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetGrabbedWindow")] public static extern WindowHandle GetGrabbedWindow(); @@ -4278,6 +5682,40 @@ public static MaybeBool GetMasksForPixelFormat( [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] public static extern int GetMaxHapticEffectsPlaying(HapticHandle haptic); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetMemoryFunctions")] + public static extern void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) + { + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) + { + GetMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetMice")] [return: NativeTypeName("SDL_MouseID *")] public static extern uint* GetMice(int* count); @@ -4343,6 +5781,9 @@ public static extern DisplayOrientation GetNaturalDisplayOrientation( [NativeTypeName("SDL_DisplayID")] uint displayID ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumAllocations")] + public static extern int GetNumAllocations(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumAudioDrivers")] public static extern int GetNumAudioDrivers(); @@ -4381,6 +5822,9 @@ public static long GetNumberProperty( [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumGamepadTouchpads")] public static extern int GetNumGamepadTouchpads(GamepadHandle gamepad); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumGPUDrivers")] + public static extern int GetNumGPUDrivers(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumHapticAxes")] public static extern int GetNumHapticAxes(HapticHandle haptic); @@ -4405,6 +5849,40 @@ public static long GetNumberProperty( [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetNumVideoDrivers")] public static extern int GetNumVideoDrivers(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetOriginalMemoryFunctions")] + public static extern void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) + { + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) + { + GetOriginalMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetPathInfo")] [return: NativeTypeName("bool")] public static extern byte GetPathInfo( @@ -4584,6 +6062,16 @@ public static Ptr GetPrefPath( [return: NativeTypeName("char *")] public static extern sbyte* GetPrimarySelectionTextRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetProcessInput")] + public static extern IOStreamHandle GetProcessInput(ProcessHandle process); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetProcessOutput")] + public static extern IOStreamHandle GetProcessOutput(ProcessHandle process); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetProcessProperties")] + [return: NativeTypeName("SDL_PropertiesID")] + public static extern uint GetProcessProperties(ProcessHandle process); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GetPropertyType")] public static extern PropertyType GetPropertyType( [NativeTypeName("SDL_PropertiesID")] uint props, @@ -6781,6 +8269,83 @@ Ref count } } + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] + public static MaybeBool GPUSupportsProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => (MaybeBool)(byte)GPUSupportsPropertiesRaw(props); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GPUSupportsProperties")] + [return: NativeTypeName("bool")] + public static extern byte GPUSupportsPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint props + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GPUSupportsShaderFormats")] + [return: NativeTypeName("bool")] + public static extern byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)GPUSupportsShaderFormats(format_flags, __dsl_name); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] + [return: NativeTypeName("Uint32")] + public static extern uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] + public static MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => (MaybeBool)(byte)GPUTextureSupportsFormatRaw(device, format, type, usage); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GPUTextureSupportsFormat")] + [return: NativeTypeName("bool")] + public static extern byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + public static MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => (MaybeBool)(byte)GPUTextureSupportsSampleCountRaw(device, format, sample_count); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GPUTextureSupportsSampleCount")] + [return: NativeTypeName("bool")] + public static extern byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_GUIDToString")] public static extern void GuidToString( Guid guid, @@ -7548,6 +9113,103 @@ public static MaybeBool HideWindow(WindowHandle window) => [return: NativeTypeName("bool")] public static extern byte HideWindowRaw(WindowHandle window); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_iconv")] + [return: NativeTypeName("size_t")] + public static extern nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ) + { + fixed (nuint* __dsl_outbytesleft = outbytesleft) + fixed (sbyte** __dsl_outbuf = outbuf) + fixed (nuint* __dsl_inbytesleft = inbytesleft) + fixed (sbyte** __dsl_inbuf = inbuf) + { + return (nuint)Iconv( + cd, + __dsl_inbuf, + __dsl_inbytesleft, + __dsl_outbuf, + __dsl_outbytesleft + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_iconv_close")] + public static extern int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_iconv_open")] + [return: NativeTypeName("SDL_iconv_t")] + public static extern IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ); + + [return: NativeTypeName("SDL_iconv_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ) + { + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) + { + return (IconvDataTHandle)IconvOpen(__dsl_tocode, __dsl_fromcode); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_iconv_string")] + [return: NativeTypeName("char *")] + public static extern sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) + { + fixed (sbyte* __dsl_inbuf = inbuf) + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) + { + return (sbyte*)IconvString(__dsl_tocode, __dsl_fromcode, __dsl_inbuf, inbytesleft); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Init")] @@ -7578,6 +9240,28 @@ public static MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] ui [return: NativeTypeName("bool")] public static extern byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_InsertGPUDebugLabel")] + public static extern void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + InsertGPUDebugLabel(command_buffer, __dsl_text); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_IOFromConstMem")] public static extern IOStreamHandle IOFromConstMem( [NativeTypeName("const void *")] void* mem, @@ -7672,6 +9356,21 @@ public static nuint IOvprintf( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isalnum")] + public static extern int Isalnum(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isalpha")] + public static extern int Isalpha(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isblank")] + public static extern int Isblank(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_iscntrl")] + public static extern int Iscntrl(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isdigit")] + public static extern int Isdigit(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] @@ -7683,6 +9382,15 @@ public static MaybeBool IsGamepad( [return: NativeTypeName("bool")] public static extern byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isgraph")] + public static extern int Isgraph(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isinf")] + public static extern int Isinf(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isinff")] + public static extern int Isinff(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] @@ -7706,6 +9414,9 @@ public static extern byte IsJoystickVirtualRaw( [NativeTypeName("SDL_JoystickID")] uint instance_id ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_islower")] + public static extern int Islower(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] @@ -7715,6 +9426,21 @@ public static extern byte IsJoystickVirtualRaw( [return: NativeTypeName("bool")] public static extern byte IsMouseHapticRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isnan")] + public static extern int Isnan(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isnanf")] + public static extern int Isnanf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isprint")] + public static extern int Isprint(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ispunct")] + public static extern int Ispunct(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isspace")] + public static extern int Isspace(int x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] @@ -7733,6 +9459,38 @@ public static extern byte IsJoystickVirtualRaw( [return: NativeTypeName("bool")] public static extern byte IsTVRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isupper")] + public static extern int Isupper(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_isxdigit")] + public static extern int Isxdigit(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_itoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Itoa( + int value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Itoa( + int value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Itoa(value, __dsl_str, radix); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] @@ -7753,6 +9511,47 @@ public static MaybeBool JoystickEventsEnabled() => [return: NativeTypeName("bool")] public static extern byte JoystickEventsEnabledRaw(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_KillProcess")] + [return: NativeTypeName("bool")] + public static extern byte KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte force + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + public static MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ) => (MaybeBool)(byte)KillProcess(process, (byte)force); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_lltoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Lltoa(value, __dsl_str, radix); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_LoadBMP")] public static extern Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file); @@ -8077,6 +9876,18 @@ Ref2D surface } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_log")] + public static extern double Log(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_log10")] + public static extern double Log10(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_log10f")] + public static extern float Log10F(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_logf")] + public static extern float Logf(float x); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_LogMessageV")] public static extern void LogMessageV( int category, @@ -8104,6 +9915,84 @@ public static void LogMessageV( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_lround")] + [return: NativeTypeName("long")] + public static extern nint Lround(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_lroundf")] + [return: NativeTypeName("long")] + public static extern nint Lroundf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ltoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ltoa(value, __dsl_str, radix); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_main")] + public static extern int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv) + { + fixed (sbyte** __dsl_argv = argv) + { + return (int)Main(argc, __dsl_argv); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Malloc([NativeTypeName("size_t")] nuint size) => (void*)MallocRaw(size); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_malloc")] + public static extern void* MallocRaw([NativeTypeName("size_t")] nuint size); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_MapGPUTransferBuffer")] + public static extern void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ) => (void*)MapGPUTransferBuffer(device, transfer_buffer, (byte)cycle); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_MapRGB")] [return: NativeTypeName("Uint32")] public static extern uint MapRGB( @@ -8236,12 +10125,61 @@ public static MaybeBool MaximizeWindow(WindowHandle window) => [return: NativeTypeName("bool")] public static extern byte MaximizeWindowRaw(WindowHandle window); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_memcmp")] + public static extern int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_s2 = s2) + fixed (void* __dsl_s1 = s1) + { + return (int)Memcmp(__dsl_s1, __dsl_s2, len); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_MemoryBarrierAcquireFunction")] public static extern void MemoryBarrierAcquireFunction(); [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_MemoryBarrierReleaseFunction")] public static extern void MemoryBarrierReleaseFunction(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_memset4")] + public static extern void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) + { + fixed (void* __dsl_dst = dst) + { + return (void*)Memset4(__dsl_dst, val, dwords); + } + } + [return: NativeTypeName("SDL_MetalView")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] @@ -8327,6 +10265,64 @@ float volume } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_modf")] + public static extern double Modf(double x, double* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Modf(double x, Ref y) + { + fixed (double* __dsl_y = y) + { + return (double)Modf(x, __dsl_y); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_modff")] + public static extern float Modff(float x, float* y); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Modff(float x, Ref y) + { + fixed (float* __dsl_y = y) + { + return (float)Modff(x, __dsl_y); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_murmur3_32")] + [return: NativeTypeName("Uint32")] + public static extern uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) + { + fixed (void* __dsl_data = data) + { + return (uint)Murmur3X32(__dsl_data, len, seed); + } + } + [DllImport( "SDL3", ExactSpelling = true, @@ -8705,6 +10701,15 @@ public static MaybeBool PollEvent(Ref @event) } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PopGPUDebugGroup")] + public static extern void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_pow")] + public static extern double Pow(double x, double y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_powf")] + public static extern float Powf(float x, float y); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PremultiplyAlpha")] [return: NativeTypeName("bool")] public static extern byte PremultiplyAlpha( @@ -8800,6 +10805,106 @@ public static MaybeBool PushEvent(Ref @event) } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PushGPUComputeUniformData")] + public static extern void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUComputeUniformData(command_buffer, slot_index, __dsl_data, length); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PushGPUDebugGroup")] + public static extern void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + PushGPUDebugGroup(command_buffer, __dsl_name); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PushGPUFragmentUniformData")] + public static extern void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUFragmentUniformData(command_buffer, slot_index, __dsl_data, length); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PushGPUVertexUniformData")] + public static extern void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUVertexUniformData(command_buffer, slot_index, __dsl_data, length); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_PutAudioStreamData")] [return: NativeTypeName("bool")] public static extern byte PutAudioStreamData( @@ -8826,6 +10931,71 @@ int len } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_qsort")] + public static extern void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) + { + fixed (void* __dsl_base = @base) + { + Qsort(__dsl_base, nmemb, size, compare); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_qsort_r")] + public static extern void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) + { + QsortR(__dsl_base, nmemb, size, compare, __dsl_userdata); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + public static MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + (MaybeBool)(byte)QueryGPUFenceRaw(device, fence); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_QueryGPUFence")] + [return: NativeTypeName("bool")] + public static extern byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Quit")] public static extern void Quit(); @@ -8842,6 +11012,75 @@ public static MaybeBool RaiseWindow(WindowHandle window) => [return: NativeTypeName("bool")] public static extern byte RaiseWindowRaw(WindowHandle window); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_rand")] + [return: NativeTypeName("Sint32")] + public static extern int Rand([NativeTypeName("Sint32")] int n); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_rand_bits")] + [return: NativeTypeName("Uint32")] + public static extern uint RandBits(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_rand_bits_r")] + [return: NativeTypeName("Uint32")] + public static extern uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint RandBitsR([NativeTypeName("Uint64 *")] Ref state) + { + fixed (ulong* __dsl_state = state) + { + return (uint)RandBitsR(__dsl_state); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_rand_r")] + [return: NativeTypeName("Sint32")] + public static extern int RandR( + [NativeTypeName("Uint64 *")] ulong* state, + [NativeTypeName("Sint32")] int n + ); + + [return: NativeTypeName("Sint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RandR( + [NativeTypeName("Uint64 *")] Ref state, + [NativeTypeName("Sint32")] int n + ) + { + fixed (ulong* __dsl_state = state) + { + return (int)RandR(__dsl_state, n); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_randf")] + public static extern float Randf(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_randf_r")] + public static extern float RandfR([NativeTypeName("Uint64 *")] ulong* state); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float RandfR([NativeTypeName("Uint64 *")] Ref state) + { + fixed (ulong* __dsl_state = state) + { + return (float)RandfR(__dsl_state); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReadIO")] [return: NativeTypeName("size_t")] public static extern nuint ReadIO( @@ -8868,6 +11107,31 @@ public static nuint ReadIO( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReadProcess")] + public static extern void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ) + { + fixed (int* __dsl_exitcode = exitcode) + fixed (nuint* __dsl_datasize = datasize) + { + return (void*)ReadProcess(process, __dsl_datasize, __dsl_exitcode); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReadS16BE")] [return: NativeTypeName("bool")] public static extern byte ReadS16BE( @@ -9320,6 +11584,22 @@ public static MaybeBool ReadU8( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_realloc")] + public static extern void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size) + { + fixed (void* __dsl_mem = mem) + { + return (void*)Realloc(__dsl_mem, size); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_RegisterEvents")] [return: NativeTypeName("Uint32")] public static extern uint RegisterEvents(int numevents); @@ -9340,6 +11620,51 @@ public static void ReleaseCameraFrame(CameraHandle camera, Ref frame) } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUBuffer")] + public static extern void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUComputePipeline")] + public static extern void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUFence")] + public static extern void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] + public static extern void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUSampler")] + public static extern void ReleaseGPUSampler( + GPUDeviceHandle device, + GPUSamplerHandle sampler + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUShader")] + public static extern void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUTexture")] + public static extern void ReleaseGPUTexture( + GPUDeviceHandle device, + GPUTextureHandle texture + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseGPUTransferBuffer")] + public static extern void ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] + public static extern void ReleaseWindowFromGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] @@ -10233,6 +12558,12 @@ public static MaybeBool ResumeHaptic(HapticHandle haptic) => [return: NativeTypeName("bool")] public static extern byte ResumeHapticRaw(HapticHandle haptic); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_round")] + public static extern double Round(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_roundf")] + public static extern float Roundf(float x); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] @@ -10327,6 +12658,33 @@ public static extern byte RumbleJoystickTriggersRaw( [NativeTypeName("Uint32")] uint duration_ms ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_RunApp")] + public static extern int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ) + { + fixed (void* __dsl_reserved = reserved) + fixed (sbyte** __dsl_argv = argv) + { + return (int)RunApp(argc, __dsl_argv, mainFunction, __dsl_reserved); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] @@ -10395,6 +12753,12 @@ public static MaybeBool SaveBMPIO( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_scalbn")] + public static extern double Scalbn(double x, int n); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_scalbnf")] + public static extern float Scalbnf(float x, int n); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ScaleSurface")] public static extern Surface* ScaleSurface( Surface* surface, @@ -10972,6 +13336,61 @@ public static MaybeBool SetCursor(CursorHandle cursor) => [return: NativeTypeName("bool")] public static extern byte SetCursorRaw(CursorHandle cursor); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_setenv_unsafe")] + public static extern int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (int)SetenvUnsafe(__dsl_name, __dsl_value, overwrite); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetEnvironmentVariable")] + [return: NativeTypeName("bool")] + public static extern byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)SetEnvironmentVariable(env, __dsl_name, __dsl_value, (byte)overwrite); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetErrorV")] [return: NativeTypeName("bool")] public static extern byte SetErrorV( @@ -11139,6 +13558,136 @@ public static MaybeBool SetGamepadSensorEnabled( [NativeTypeName("bool")] MaybeBool enabled ) => (MaybeBool)(byte)SetGamepadSensorEnabled(gamepad, type, (byte)enabled); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUBlendConstants")] + public static extern void SetGPUBlendConstants( + GPURenderPassHandle render_pass, + FColor blend_constants + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUBufferName")] + public static extern void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + SetGPUBufferName(device, buffer, __dsl_text); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUScissor")] + public static extern void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ) + { + fixed (Rect* __dsl_scissor = scissor) + { + SetGPUScissor(render_pass, __dsl_scissor); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUStencilReference")] + public static extern void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + public static MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => + (MaybeBool) + (byte)SetGPUSwapchainParametersRaw( + device, + window, + swapchain_composition, + present_mode + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUSwapchainParameters")] + [return: NativeTypeName("bool")] + public static extern byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUTextureName")] + public static extern void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + SetGPUTextureName(device, texture, __dsl_text); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetGPUViewport")] + public static extern void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ) + { + fixed (GPUViewport* __dsl_viewport = viewport) + { + SetGPUViewport(render_pass, __dsl_viewport); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] @@ -11434,6 +13983,30 @@ public static MaybeBool SetLogPriorityPrefix( } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetMainReady")] + public static extern void SetMainReady(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + public static MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => + (MaybeBool) + (byte)SetMemoryFunctionsRaw(malloc_func, calloc_func, realloc_func, free_func); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetMemoryFunctions")] + [return: NativeTypeName("bool")] + public static extern byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SetModState")] public static extern void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate); @@ -12808,6 +15381,21 @@ public static MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, i [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SignalSemaphore")] public static extern void SignalSemaphore(SemaphoreHandle sem); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_sin")] + public static extern double Sin(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_sinf")] + public static extern float Sinf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_sqrt")] + public static extern double Sqrt(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_sqrtf")] + public static extern float Sqrtf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_srand")] + public static extern void Srand([NativeTypeName("Uint64")] ulong seed); + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] @@ -12833,6 +15421,56 @@ public static extern byte StartTextInputWithPropertiesRaw( [NativeTypeName("SDL_PropertiesID")] uint props ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_StepBackUTF8")] + [return: NativeTypeName("Uint32")] + public static extern uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ) + { + fixed (sbyte** __dsl_pstr = pstr) + fixed (sbyte* __dsl_start = start) + { + return (uint)StepBackUTF8(__dsl_start, __dsl_pstr); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_StepUTF8")] + [return: NativeTypeName("Uint32")] + public static extern uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ) + { + fixed (nuint* __dsl_pslen = pslen) + fixed (sbyte** __dsl_pstr = pstr) + { + return (uint)StepUTF8(__dsl_pstr, __dsl_pslen); + } + } + [return: NativeTypeName("bool")] [Transformed] [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] @@ -12883,40964 +15521,58107 @@ public static MaybeBool StorageReady(StorageHandle storage) => [return: NativeTypeName("bool")] public static extern byte StorageReadyRaw(StorageHandle storage); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_StringToGUID")] - public static extern Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strcasecmp")] + public static extern int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) + public static int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) { - fixed (sbyte* __dsl_pchGUID = pchGUID) + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) { - return (Guid)StringToGuid(__dsl_pchGUID); + return (int)Strcasecmp(__dsl_str1, __dsl_str2); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasAlternateImages")] - [return: NativeTypeName("bool")] - public static extern byte SurfaceHasAlternateImages(Surface* surface); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strcasestr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasAlternateImages(Ref surface) + public static Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) { - return (MaybeBool)(byte)SurfaceHasAlternateImages(__dsl_surface); + return (sbyte*)Strcasestr(__dsl_haystack, __dsl_needle); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasColorKey")] - [return: NativeTypeName("bool")] - public static extern byte SurfaceHasColorKey(Surface* surface); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strchr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasColorKey(Ref surface) + public static Ptr Strchr([NativeTypeName("const char *")] Ref str, int c) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)SurfaceHasColorKey(__dsl_surface); + return (sbyte*)Strchr(__dsl_str, c); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasRLE")] - [return: NativeTypeName("bool")] - public static extern byte SurfaceHasRLE(Surface* surface); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strcmp")] + public static extern int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasRLE(Ref surface) + public static int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) { - return (MaybeBool)(byte)SurfaceHasRLE(__dsl_surface); + return (int)Strcmp(__dsl_str1, __dsl_str2); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] - public static MaybeBool SyncWindow(WindowHandle window) => - (MaybeBool)(byte)SyncWindowRaw(window); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SyncWindow")] - [return: NativeTypeName("bool")] - public static extern byte SyncWindowRaw(WindowHandle window); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TellIO")] - [return: NativeTypeName("Sint64")] - public static extern long TellIO(IOStreamHandle context); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strdup")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strdup([NativeTypeName("const char *")] sbyte* str); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] - public static MaybeBool TextInputActive(WindowHandle window) => - (MaybeBool)(byte)TextInputActiveRaw(window); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TextInputActive")] - [return: NativeTypeName("bool")] - public static extern byte TextInputActiveRaw(WindowHandle window); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeFromWindows")] - [return: NativeTypeName("SDL_Time")] - public static extern long TimeFromWindows( - [NativeTypeName("Uint32")] uint dwLowDateTime, - [NativeTypeName("Uint32")] uint dwHighDateTime - ); + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strdup([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strdup(__dsl_str); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeToDateTime")] - [return: NativeTypeName("bool")] - public static extern byte TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - DateTime* dt, - [NativeTypeName("bool")] byte localTime - ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_StringToGUID")] + public static extern Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - Ref dt, - [NativeTypeName("bool")] MaybeBool localTime - ) + public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) { - fixed (DateTime* __dsl_dt = dt) + fixed (sbyte* __dsl_pchGUID = pchGUID) { - return (MaybeBool)(byte)TimeToDateTime(ticks, __dsl_dt, (byte)localTime); + return (Guid)StringToGuid(__dsl_pchGUID); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeToWindows")] - public static extern void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] uint* dwLowDateTime, - [NativeTypeName("Uint32 *")] uint* dwHighDateTime + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strlcat")] + [return: NativeTypeName("size_t")] + public static extern nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen ); + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] Ref dwLowDateTime, - [NativeTypeName("Uint32 *")] Ref dwHighDateTime + public static nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (uint* __dsl_dwHighDateTime = dwHighDateTime) - fixed (uint* __dsl_dwLowDateTime = dwLowDateTime) + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) { - TimeToWindows(ticks, __dsl_dwLowDateTime, __dsl_dwHighDateTime); + return (nuint)Strlcat(__dsl_dst, __dsl_src, maxlen); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] - public static MaybeBool TryLockMutex(MutexHandle mutex) => - (MaybeBool)(byte)TryLockMutexRaw(mutex); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockMutex")] - [return: NativeTypeName("bool")] - public static extern byte TryLockMutexRaw(MutexHandle mutex); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] - public static MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => - (MaybeBool)(byte)TryLockRWLockForReadingRaw(rwlock); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockRWLockForReading")] - [return: NativeTypeName("bool")] - public static extern byte TryLockRWLockForReadingRaw(RWLockHandle rwlock); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] - public static MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => - (MaybeBool)(byte)TryLockRWLockForWritingRaw(rwlock); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockRWLockForWriting")] - [return: NativeTypeName("bool")] - public static extern byte TryLockRWLockForWritingRaw(RWLockHandle rwlock); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockSpinlock")] - [return: NativeTypeName("bool")] - public static extern byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strlcpy")] + [return: NativeTypeName("size_t")] + public static extern nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryLockSpinlock( - [NativeTypeName("SDL_SpinLock *")] Ref @lock + public static nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (int* __dsl_lock = @lock) + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) { - return (MaybeBool)(byte)TryLockSpinlock(__dsl_lock); + return (nuint)Strlcpy(__dsl_dst, __dsl_src, maxlen); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] - public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => - (MaybeBool)(byte)TryWaitSemaphoreRaw(sem); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryWaitSemaphore")] - [return: NativeTypeName("bool")] - public static extern byte TryWaitSemaphoreRaw(SemaphoreHandle sem); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnbindAudioStream")] - public static extern void UnbindAudioStream(AudioStreamHandle stream); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnbindAudioStreams")] - public static extern void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strlen")] + [return: NativeTypeName("size_t")] + public static extern nuint Strlen([NativeTypeName("const char *")] sbyte* str); + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnbindAudioStreams(Ref streams, int num_streams) + public static nuint Strlen([NativeTypeName("const char *")] Ref str) { - fixed (AudioStreamHandle* __dsl_streams = streams) + fixed (sbyte* __dsl_str = str) { - UnbindAudioStreams(__dsl_streams, num_streams); + return (nuint)Strlen(__dsl_str); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnloadObject")] - public static extern void UnloadObject(SharedObjectHandle handle); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] - public static MaybeBool UnlockAudioStream(AudioStreamHandle stream) => - (MaybeBool)(byte)UnlockAudioStreamRaw(stream); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockAudioStream")] - [return: NativeTypeName("bool")] - public static extern byte UnlockAudioStreamRaw(AudioStreamHandle stream); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockJoysticks")] - public static extern void UnlockJoysticks(); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockMutex")] - public static extern void UnlockMutex(MutexHandle mutex); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockProperties")] - public static extern void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockRWLock")] - public static extern void UnlockRWLock(RWLockHandle rwlock); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockSpinlock")] - public static extern void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strlwr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strlwr([NativeTypeName("char *")] sbyte* str); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + public static Ptr Strlwr([NativeTypeName("char *")] Ref str) { - fixed (int* __dsl_lock = @lock) + fixed (sbyte* __dsl_str = str) { - UnlockSpinlock(__dsl_lock); + return (sbyte*)Strlwr(__dsl_str); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockSurface")] - public static extern void UnlockSurface(Surface* surface); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strncasecmp")] + public static extern int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSurface(Ref surface) + public static int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) { - UnlockSurface(__dsl_surface); + return (int)Strncasecmp(__dsl_str1, __dsl_str2, maxlen); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockTexture")] - public static extern void UnlockTexture(Texture* texture); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strncmp")] + public static extern int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockTexture(Ref texture) + public static int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) { - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) { - UnlockTexture(__dsl_texture); + return (int)Strncmp(__dsl_str1, __dsl_str2, maxlen); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateGamepads")] - public static extern void UpdateGamepads(); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateHapticEffect")] - [return: NativeTypeName("bool")] - public static extern byte UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strndup")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] Ref data + public static Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (HapticEffect* __dsl_data = data) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)UpdateHapticEffect(haptic, effect, __dsl_data); + return (sbyte*)Strndup(__dsl_str, maxlen); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateJoysticks")] - public static extern void UpdateJoysticks(); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateNVTexture")] - [return: NativeTypeName("bool")] - public static extern byte UpdateNVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* UVplane, - int UVpitch + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strnlen")] + [return: NativeTypeName("size_t")] + public static extern nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateNVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref UVplane, - int UVpitch + public static nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (byte* __dsl_UVplane = UVplane) - fixed (byte* __dsl_Yplane = Yplane) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool) - (byte)UpdateNVTexture( - __dsl_texture, - __dsl_rect, - __dsl_Yplane, - Ypitch, - __dsl_UVplane, - UVpitch - ); + return (nuint)Strnlen(__dsl_str, maxlen); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateSensors")] - public static extern void UpdateSensors(); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateTexture")] - [return: NativeTypeName("bool")] - public static extern byte UpdateTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const void *")] void* pixels, - int pitch + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strnstr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const void *")] Ref pixels, - int pitch + public static Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (void* __dsl_pixels = pixels) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) { - return (MaybeBool) - (byte)UpdateTexture(__dsl_texture, __dsl_rect, __dsl_pixels, pitch); + return (sbyte*)Strnstr(__dsl_haystack, __dsl_needle, maxlen); } } - [return: NativeTypeName("bool")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strpbrk")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ); + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] - public static MaybeBool UpdateWindowSurface(WindowHandle window) => - (MaybeBool)(byte)UpdateWindowSurfaceRaw(window); + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ) + { + fixed (sbyte* __dsl_breakset = breakset) + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strpbrk(__dsl_str, __dsl_breakset); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateWindowSurface")] - [return: NativeTypeName("bool")] - public static extern byte UpdateWindowSurfaceRaw(WindowHandle window); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strrchr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateWindowSurfaceRects")] - [return: NativeTypeName("bool")] - public static extern byte UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int numrects + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strrchr(__dsl_str, c); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strrev")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strrev([NativeTypeName("char *")] sbyte* str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strrev([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strrev(__dsl_str); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strstr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int numrects + public static Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle ) { - fixed (Rect* __dsl_rects = rects) + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) { - return (MaybeBool) - (byte)UpdateWindowSurfaceRects(window, __dsl_rects, numrects); + return (sbyte*)Strstr(__dsl_haystack, __dsl_needle); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateYUVTexture")] - [return: NativeTypeName("bool")] - public static extern byte UpdateYUVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] byte* Vplane, - int Vpitch + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtod")] + public static extern double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateYUVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] Ref Vplane, - int Vpitch + public static double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp ) { - fixed (byte* __dsl_Vplane = Vplane) - fixed (byte* __dsl_Uplane = Uplane) - fixed (byte* __dsl_Yplane = Yplane) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool) - (byte)UpdateYUVTexture( - __dsl_texture, - __dsl_rect, - __dsl_Yplane, - Ypitch, - __dsl_Uplane, - Upitch, - __dsl_Vplane, - Vpitch - ); + return (double)Strtod(__dsl_str, __dsl_endp); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitCondition")] - public static extern void WaitCondition(ConditionHandle cond, MutexHandle mutex); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtok_r")] + [return: NativeTypeName("char *")] + public static extern sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] - public static MaybeBool WaitConditionTimeout( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS - ) => (MaybeBool)(byte)WaitConditionTimeoutRaw(cond, mutex, timeoutMS); + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ) + { + fixed (sbyte** __dsl_saveptr = saveptr) + fixed (sbyte* __dsl_s2 = s2) + fixed (sbyte* __dsl_s1 = s1) + { + return (sbyte*)StrtokR(__dsl_s1, __dsl_s2, __dsl_saveptr); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitConditionTimeout")] - [return: NativeTypeName("bool")] - public static extern byte WaitConditionTimeoutRaw( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtol")] + [return: NativeTypeName("long")] + public static extern nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base ); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitEvent")] - [return: NativeTypeName("bool")] - public static extern byte WaitEvent(Event* @event); - - [return: NativeTypeName("bool")] + [return: NativeTypeName("long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WaitEvent(Ref @event) + public static nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) { - fixed (Event* __dsl_event = @event) + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)WaitEvent(__dsl_event); + return (nint)Strtol(__dsl_str, __dsl_endp, @base); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitEventTimeout")] - [return: NativeTypeName("bool")] - public static extern byte WaitEventTimeout( - Event* @event, - [NativeTypeName("Sint32")] int timeoutMS + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtoll")] + [return: NativeTypeName("long long")] + public static extern long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("long long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WaitEventTimeout( - Ref @event, - [NativeTypeName("Sint32")] int timeoutMS + public static long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base ) { - fixed (Event* __dsl_event = @event) + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)WaitEventTimeout(__dsl_event, timeoutMS); + return (long)Strtoll(__dsl_str, __dsl_endp, @base); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitSemaphore")] - public static extern void WaitSemaphore(SemaphoreHandle sem); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtoul")] + [return: NativeTypeName("unsigned long")] + public static extern nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("unsigned long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] - public static MaybeBool WaitSemaphoreTimeout( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS - ) => (MaybeBool)(byte)WaitSemaphoreTimeoutRaw(sem, timeoutMS); + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (nuint)Strtoul(__dsl_str, __dsl_endp, @base); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitSemaphoreTimeout")] - [return: NativeTypeName("bool")] - public static extern byte WaitSemaphoreTimeoutRaw( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strtoull")] + [return: NativeTypeName("unsigned long long")] + public static extern ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base ); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitThread")] - public static extern void WaitThread(ThreadHandle thread, int* status); + [return: NativeTypeName("unsigned long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (ulong)Strtoull(__dsl_str, __dsl_endp, @base); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_strupr")] + [return: NativeTypeName("char *")] + public static extern sbyte* Strupr([NativeTypeName("char *")] sbyte* str); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WaitThread(ThreadHandle thread, Ref status) + public static Ptr Strupr([NativeTypeName("char *")] Ref str) { - fixed (int* __dsl_status = status) + fixed (sbyte* __dsl_str = str) { - WaitThread(thread, __dsl_status); + return (sbyte*)Strupr(__dsl_str); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] - public static MaybeBool WarpMouseGlobal(float x, float y) => - (MaybeBool)(byte)WarpMouseGlobalRaw(x, y); + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + public static MaybeBool SubmitGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ) => (MaybeBool)(byte)SubmitGPUCommandBufferRaw(command_buffer); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WarpMouseGlobal")] - [return: NativeTypeName("bool")] - public static extern byte WarpMouseGlobalRaw(float x, float y); + [DllImport( + "SDL3", + ExactSpelling = true, + EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence" + )] + public static extern GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WarpMouseInWindow")] - public static extern void WarpMouseInWindow(WindowHandle window, float x, float y); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SubmitGPUCommandBuffer")] + [return: NativeTypeName("bool")] + public static extern byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WasInit")] - [return: NativeTypeName("SDL_InitFlags")] - public static extern uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasAlternateImages")] + [return: NativeTypeName("bool")] + public static extern byte SurfaceHasAlternateImages(Surface* surface); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] - public static MaybeBool WindowHasSurface(WindowHandle window) => - (MaybeBool)(byte)WindowHasSurfaceRaw(window); + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SurfaceHasAlternateImages(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SurfaceHasAlternateImages(__dsl_surface); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WindowHasSurface")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasColorKey")] [return: NativeTypeName("bool")] - public static extern byte WindowHasSurfaceRaw(WindowHandle window); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteIO")] - [return: NativeTypeName("size_t")] - public static extern nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] void* ptr, - [NativeTypeName("size_t")] nuint size - ); + public static extern byte SurfaceHasColorKey(Surface* surface); - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] Ref ptr, - [NativeTypeName("size_t")] nuint size - ) + public static MaybeBool SurfaceHasColorKey(Ref surface) { - fixed (void* __dsl_ptr = ptr) + fixed (Surface* __dsl_surface = surface) { - return (nuint)WriteIO(context, __dsl_ptr, size); + return (MaybeBool)(byte)SurfaceHasColorKey(__dsl_surface); } } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SurfaceHasRLE")] [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] - public static MaybeBool WriteS16BE( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => (MaybeBool)(byte)WriteS16BERaw(dst, value); + public static extern byte SurfaceHasRLE(Surface* surface); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS16BE")] [return: NativeTypeName("bool")] - public static extern byte WriteS16BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SurfaceHasRLE(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SurfaceHasRLE(__dsl_surface); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] - public static MaybeBool WriteS16LE( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => (MaybeBool)(byte)WriteS16LERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + public static MaybeBool SyncWindow(WindowHandle window) => + (MaybeBool)(byte)SyncWindowRaw(window); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS16LE")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_SyncWindow")] [return: NativeTypeName("bool")] - public static extern byte WriteS16LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ); + public static extern byte SyncWindowRaw(WindowHandle window); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_tan")] + public static extern double Tan(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_tanf")] + public static extern float Tanf(float x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TellIO")] + [return: NativeTypeName("Sint64")] + public static extern long TellIO(IOStreamHandle context); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] - public static MaybeBool WriteS32BE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => (MaybeBool)(byte)WriteS32BERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + public static MaybeBool TextInputActive(WindowHandle window) => + (MaybeBool)(byte)TextInputActiveRaw(window); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS32BE")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TextInputActive")] [return: NativeTypeName("bool")] - public static extern byte WriteS32BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value + public static extern byte TextInputActiveRaw(WindowHandle window); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeFromWindows")] + [return: NativeTypeName("SDL_Time")] + public static extern long TimeFromWindows( + [NativeTypeName("Uint32")] uint dwLowDateTime, + [NativeTypeName("Uint32")] uint dwHighDateTime ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeToDateTime")] [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] - public static MaybeBool WriteS32LE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => (MaybeBool)(byte)WriteS32LERaw(dst, value); + public static extern byte TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + DateTime* dt, + [NativeTypeName("bool")] byte localTime + ); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS32LE")] [return: NativeTypeName("bool")] - public static extern byte WriteS32LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + Ref dt, + [NativeTypeName("bool")] MaybeBool localTime + ) + { + fixed (DateTime* __dsl_dt = dt) + { + return (MaybeBool)(byte)TimeToDateTime(ticks, __dsl_dt, (byte)localTime); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TimeToWindows")] + public static extern void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] uint* dwLowDateTime, + [NativeTypeName("Uint32 *")] uint* dwHighDateTime ); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] Ref dwLowDateTime, + [NativeTypeName("Uint32 *")] Ref dwHighDateTime + ) + { + fixed (uint* __dsl_dwHighDateTime = dwHighDateTime) + fixed (uint* __dsl_dwLowDateTime = dwLowDateTime) + { + TimeToWindows(ticks, __dsl_dwLowDateTime, __dsl_dwHighDateTime); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_tolower")] + public static extern int Tolower(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_toupper")] + public static extern int Toupper(int x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_trunc")] + public static extern double Trunc(double x); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_truncf")] + public static extern float Truncf(float x); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] - public static MaybeBool WriteS64BE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => (MaybeBool)(byte)WriteS64BERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + public static MaybeBool TryLockMutex(MutexHandle mutex) => + (MaybeBool)(byte)TryLockMutexRaw(mutex); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS64BE")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockMutex")] [return: NativeTypeName("bool")] - public static extern byte WriteS64BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ); + public static extern byte TryLockMutexRaw(MutexHandle mutex); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] - public static MaybeBool WriteS64LE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => (MaybeBool)(byte)WriteS64LERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + public static MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => + (MaybeBool)(byte)TryLockRWLockForReadingRaw(rwlock); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS64LE")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockRWLockForReading")] [return: NativeTypeName("bool")] - public static extern byte WriteS64LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ); + public static extern byte TryLockRWLockForReadingRaw(RWLockHandle rwlock); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] - public static MaybeBool WriteS8( - IOStreamHandle dst, - [NativeTypeName("Sint8")] sbyte value - ) => (MaybeBool)(byte)WriteS8Raw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + public static MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => + (MaybeBool)(byte)TryLockRWLockForWritingRaw(rwlock); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS8")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockRWLockForWriting")] [return: NativeTypeName("bool")] - public static extern byte WriteS8Raw( - IOStreamHandle dst, - [NativeTypeName("Sint8")] sbyte value - ); + public static extern byte TryLockRWLockForWritingRaw(RWLockHandle rwlock); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteStorageFile")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryLockSpinlock")] [return: NativeTypeName("bool")] - public static extern byte WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const void *")] void* source, - [NativeTypeName("Uint64")] ulong length - ); + public static extern byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const void *")] Ref source, - [NativeTypeName("Uint64")] ulong length + public static MaybeBool TryLockSpinlock( + [NativeTypeName("SDL_SpinLock *")] Ref @lock ) { - fixed (void* __dsl_source = source) - fixed (sbyte* __dsl_path = path) + fixed (int* __dsl_lock = @lock) { - return (MaybeBool) - (byte)WriteStorageFile(storage, __dsl_path, __dsl_source, length); + return (MaybeBool)(byte)TryLockSpinlock(__dsl_lock); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteSurfacePixel")] [return: NativeTypeName("bool")] - public static extern byte WriteSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => + (MaybeBool)(byte)TryWaitSemaphoreRaw(sem); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_TryWaitSemaphore")] [return: NativeTypeName("bool")] + public static extern byte TryWaitSemaphoreRaw(SemaphoreHandle sem); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UCS4ToUTF8")] + [return: NativeTypeName("char *")] + public static extern sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ); + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + public static Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_dst = dst) { - return (MaybeBool)(byte)WriteSurfacePixel(__dsl_surface, x, y, r, g, b, a); + return (sbyte*)UCS4ToUTF8(codepoint, __dsl_dst); } } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteSurfacePixelFloat")] - [return: NativeTypeName("bool")] - public static extern byte WriteSurfacePixelFloat( - Surface* surface, - int x, - int y, - float r, - float g, - float b, - float a + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_uitoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteSurfacePixelFloat( - Ref surface, - int x, - int y, - float r, - float g, - float b, - float a + public static Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool) - (byte)WriteSurfacePixelFloat(__dsl_surface, x, y, r, g, b, a); + return (sbyte*)Uitoa(value, __dsl_str, radix); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] - public static MaybeBool WriteU16BE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => (MaybeBool)(byte)WriteU16BERaw(dst, value); - - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU16BE")] - [return: NativeTypeName("bool")] - public static extern byte WriteU16BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ulltoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] - public static MaybeBool WriteU16LE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => (MaybeBool)(byte)WriteU16LERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ulltoa(value, __dsl_str, radix); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU16LE")] - [return: NativeTypeName("bool")] - public static extern byte WriteU16LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_ultoa")] + [return: NativeTypeName("char *")] + public static extern sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] - public static MaybeBool WriteU32BE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => (MaybeBool)(byte)WriteU32BERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ultoa(value, __dsl_str, radix); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU32BE")] - [return: NativeTypeName("bool")] - public static extern byte WriteU32BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnbindAudioStream")] + public static extern void UnbindAudioStream(AudioStreamHandle stream); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnbindAudioStreams")] + public static extern void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] - public static MaybeBool WriteU32LE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => (MaybeBool)(byte)WriteU32LERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnbindAudioStreams(Ref streams, int num_streams) + { + fixed (AudioStreamHandle* __dsl_streams = streams) + { + UnbindAudioStreams(__dsl_streams, num_streams); + } + } - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU32LE")] - [return: NativeTypeName("bool")] - public static extern byte WriteU32LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnloadObject")] + public static extern void UnloadObject(SharedObjectHandle handle); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] - public static MaybeBool WriteU64BE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => (MaybeBool)(byte)WriteU64BERaw(dst, value); + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + public static MaybeBool UnlockAudioStream(AudioStreamHandle stream) => + (MaybeBool)(byte)UnlockAudioStreamRaw(stream); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU64BE")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockAudioStream")] [return: NativeTypeName("bool")] - public static extern byte WriteU64BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ); + public static extern byte UnlockAudioStreamRaw(AudioStreamHandle stream); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] - public static MaybeBool WriteU64LE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => (MaybeBool)(byte)WriteU64LERaw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockJoysticks")] + public static extern void UnlockJoysticks(); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU64LE")] - [return: NativeTypeName("bool")] - public static extern byte WriteU64LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockMutex")] + public static extern void UnlockMutex(MutexHandle mutex); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] - public static MaybeBool WriteU8( - IOStreamHandle dst, - [NativeTypeName("Uint8")] byte value - ) => (MaybeBool)(byte)WriteU8Raw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockProperties")] + public static extern void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props); - [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU8")] - [return: NativeTypeName("bool")] - public static extern byte WriteU8Raw( - IOStreamHandle dst, - [NativeTypeName("Uint8")] byte value - ); - } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockRWLock")] + public static extern void UnlockRWLock(RWLockHandle rwlock); - public partial class StaticWrapper : ISdl - where T : ISdl.Static - { - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockSpinlock")] + public static extern void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] ulong* timestampNS - ) => T.AcquireCameraFrame(camera, timestampNS); + public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + { + fixed (int* __dsl_lock = @lock) + { + UnlockSpinlock(__dsl_lock); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockSurface")] + public static extern void UnlockSurface(Surface* surface); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] Ref timestampNS - ) => T.AcquireCameraFrame(camera, timestampNS); + public static void UnlockSurface(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + UnlockSurface(__dsl_surface); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnlockTexture")] + public static extern void UnlockTexture(Texture* texture); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int AddAtomicInt(AtomicInt* a, int v) => T.AddAtomicInt(a, v); + public static void UnlockTexture(Ref texture) + { + fixed (Texture* __dsl_texture = texture) + { + UnlockTexture(__dsl_texture); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnmapGPUTransferBuffer")] + public static extern void UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_unsetenv_unsafe")] + public static extern int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int AddAtomicInt(Ref a, int v) => T.AddAtomicInt(a, v); + public static int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (int)UnsetenvUnsafe(__dsl_name); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UnsetEnvironmentVariable")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => T.AddEventWatch(filter, userdata); + public static extern byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => T.AddEventWatch(filter, userdata); + public static MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)UnsetEnvironmentVariable(env, __dsl_name); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => - T.AddGamepadMapping(mapping); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateGamepads")] + public static extern void UpdateGamepads(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateHapticEffect")] + [return: NativeTypeName("bool")] + public static extern byte UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) => - T.AddGamepadMapping(mapping); + public static MaybeBool UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] Ref data + ) + { + fixed (HapticEffect* __dsl_data = data) + { + return (MaybeBool)(byte)UpdateHapticEffect(haptic, effect, __dsl_data); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public int AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => - T.AddGamepadMappingsFromFile(file); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateJoysticks")] + public static extern void UpdateJoysticks(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateNVTexture")] + [return: NativeTypeName("bool")] + public static extern byte UpdateNVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* UVplane, + int UVpitch + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int AddGamepadMappingsFromFile([NativeTypeName("const char *")] Ref file) => - T.AddGamepadMappingsFromFile(file); + public static MaybeBool UpdateNVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref UVplane, + int UVpitch + ) + { + fixed (byte* __dsl_UVplane = UVplane) + fixed (byte* __dsl_Yplane = Yplane) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateNVTexture( + __dsl_texture, + __dsl_rect, + __dsl_Yplane, + Ypitch, + __dsl_UVplane, + UVpitch + ); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio - ) => T.AddGamepadMappingsFromIO(src, closeio); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateSensors")] + public static extern void UpdateSensors(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateTexture")] + [return: NativeTypeName("bool")] + public static extern byte UpdateTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const void *")] void* pixels, + int pitch + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => T.AddGamepadMappingsFromIO(src, closeio); + public static MaybeBool UpdateTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const void *")] Ref pixels, + int pitch + ) + { + fixed (void* __dsl_pixels = pixels) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateTexture(__dsl_texture, __dsl_rect, __dsl_pixels, pitch); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte AddHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => T.AddHintCallback(name, callback, userdata); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + public static MaybeBool UpdateWindowSurface(WindowHandle window) => + (MaybeBool)(byte)UpdateWindowSurfaceRaw(window); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateWindowSurface")] + [return: NativeTypeName("bool")] + public static extern byte UpdateWindowSurfaceRaw(WindowHandle window); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [return: NativeTypeName("bool")] + public static extern byte UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int numrects + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool AddHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) => T.AddHintCallback(name, callback, userdata); + public static MaybeBool UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rects, + int numrects + ) + { + fixed (Rect* __dsl_rects = rects) + { + return (MaybeBool) + (byte)UpdateWindowSurfaceRects(window, __dsl_rects, numrects); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UpdateYUVTexture")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => - T.AddSurfaceAlternateImage(surface, image); + public static extern byte UpdateYUVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] byte* Vplane, + int Vpitch + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool AddSurfaceAlternateImage(Ref surface, Ref image) => - T.AddSurfaceAlternateImage(surface, image); + public static MaybeBool UpdateYUVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] Ref Vplane, + int Vpitch + ) + { + fixed (byte* __dsl_Vplane = Vplane) + fixed (byte* __dsl_Uplane = Uplane) + fixed (byte* __dsl_Yplane = Yplane) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateYUVTexture( + __dsl_texture, + __dsl_rect, + __dsl_Yplane, + Ypitch, + __dsl_Uplane, + Upitch, + __dsl_Vplane, + Vpitch + ); + } + } - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UploadToGPUBuffer")] + public static extern void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, - void* userdata - ) => T.AddTimer(interval, callback, userdata); + public static void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUBufferRegion* __dsl_destination = destination) + fixed (GPUTransferBufferLocation* __dsl_source = source) + { + UploadToGPUBuffer(copy_pass, __dsl_source, __dsl_destination, (byte)cycle); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_UploadToGPUTexture")] + public static extern void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ); - [return: NativeTypeName("SDL_TimerID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, - Ref userdata - ) => T.AddTimer(interval, callback, userdata); + public static void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUTextureRegion* __dsl_destination = destination) + fixed (GPUTextureTransferInfo* __dsl_source = source) + { + UploadToGPUTexture(copy_pass, __dsl_source, __dsl_destination, (byte)cycle); + } + } - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_utf8strlcpy")] + [return: NativeTypeName("size_t")] + public static extern nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, - void* userdata - ) => T.AddTimerNS(interval, callback, userdata); + public static nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ) + { + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) + { + return (nuint)Utf8Strlcpy(__dsl_dst, __dsl_src, dst_bytes); + } + } - [return: NativeTypeName("SDL_TimerID")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_utf8strlen")] + [return: NativeTypeName("size_t")] + public static extern nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str); + + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, - Ref userdata - ) => T.AddTimerNS(interval, callback, userdata); + public static nuint Utf8Strlen([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Utf8Strlen(__dsl_str); + } + } - [return: NativeTypeName("bool")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_utf8strnlen")] + [return: NativeTypeName("size_t")] + public static extern nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ); + + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool AddVulkanRenderSemaphores( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - T.AddVulkanRenderSemaphores( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); + public static nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Utf8Strnlen(__dsl_str, bytes); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte AddVulkanRenderSemaphoresRaw( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - T.AddVulkanRenderSemaphoresRaw( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_vasprintf")] + public static extern int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc - ) => T.AttachVirtualJoystick(desc); + public static int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte** __dsl_strp = strp) + { + return (int)Vasprintf(__dsl_strp, __dsl_fmt, __dsl_ap); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_vsnprintf")] + public static extern int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); - [return: NativeTypeName("SDL_JoystickID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc - ) => T.AttachVirtualJoystick(desc); + public static int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)Vsnprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_vsscanf")] + public static extern int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.AudioDevicePaused(dev); + public static int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)Vsscanf(__dsl_text, __dsl_fmt, __dsl_ap); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.AudioDevicePausedRaw(dev); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_vswprintf")] + public static extern int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BindAudioStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => T.BindAudioStream(devid, stream); + public static int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (uint* __dsl_fmt = fmt) + fixed (uint* __dsl_text = text) + { + return (int)Vswprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_CreateSurface")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BindAudioStreamRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => T.BindAudioStreamRaw(devid, stream); + public static extern byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle* streams, - int num_streams - ) => T.BindAudioStreams(devid, streams, num_streams); + public static MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ) + { + fixed (ulong* __dsl_surface = surface) + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte)VulkanCreateSurface( + window, + __dsl_instance, + __dsl_allocator, + __dsl_surface + ); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_DestroySurface")] + public static extern void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref streams, - int num_streams - ) => T.BindAudioStreams(devid, streams, num_streams); + public static void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ) + { + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + VulkanDestroySurface(__dsl_instance, surface, __dsl_allocator); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BlitSurface( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => T.BlitSurface(src, srcrect, dst, dstrect); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + [return: NativeTypeName("const char *const *")] + public static extern sbyte** VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] uint* count + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *const *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BlitSurface( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => T.BlitSurface(src, srcrect, dst, dstrect); + public static Ptr2D VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] Ref count + ) + { + fixed (uint* __dsl_count = count) + { + return (sbyte**)VulkanGetInstanceExtensions(__dsl_count); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_GetPresentationSupport")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BlitSurface9Grid( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => - T.BlitSurface9Grid( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + public static extern byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BlitSurface9Grid( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => - T.BlitSurface9Grid( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + public static MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) + { + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte)VulkanGetPresentationSupport( + __dsl_instance, + physicalDevice, + queueFamilyIndex + ); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + [DllImport( + "SDL3", + ExactSpelling = true, + EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr" )] - public byte BlitSurfaceScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => T.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); + [return: NativeTypeName("SDL_FunctionPointer")] + public static extern FunctionPointer VulkanGetVkGetInstanceProcAddr(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_LoadLibrary")] [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool BlitSurfaceScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) => T.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); + public static extern byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte BlitSurfaceTiled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => T.BlitSurfaceTiled(src, srcrect, dst, dstrect); + public static MaybeBool VulkanLoadLibrary( + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)VulkanLoadLibrary(__dsl_path); + } + } + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_Vulkan_UnloadLibrary")] + public static extern void VulkanUnloadLibrary(); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitCondition")] + public static extern void WaitCondition(ConditionHandle cond, MutexHandle mutex); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool BlitSurfaceTiled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => T.BlitSurfaceTiled(src, srcrect, dst, dstrect); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + public static MaybeBool WaitConditionTimeout( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ) => (MaybeBool)(byte)WaitConditionTimeoutRaw(cond, mutex, timeoutMS); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitConditionTimeout")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BlitSurfaceTiledWithScale( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => T.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); + public static extern byte WaitConditionTimeoutRaw( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitEvent")] + [return: NativeTypeName("bool")] + public static extern byte WaitEvent(Event* @event); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BlitSurfaceTiledWithScale( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => T.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); + public static MaybeBool WaitEvent(Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)WaitEvent(__dsl_event); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitEventTimeout")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BlitSurfaceUnchecked( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => T.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + public static extern byte WaitEventTimeout( + Event* @event, + [NativeTypeName("Sint32")] int timeoutMS + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BlitSurfaceUnchecked( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => T.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + public static MaybeBool WaitEventTimeout( + Ref @event, + [NativeTypeName("Sint32")] int timeoutMS + ) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)WaitEventTimeout(__dsl_event, timeoutMS); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitForGPUFences")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte BlitSurfaceUncheckedScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => T.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); + public static extern byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool BlitSurfaceUncheckedScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) => T.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); + public static MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ) + { + fixed (GPUFenceHandle* __dsl_fences = fences) + { + return (MaybeBool) + (byte)WaitForGPUFences(device, (byte)wait_all, __dsl_fences, num_fences); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void BroadcastCondition(ConditionHandle cond) => T.BroadcastCondition(cond); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + public static MaybeBool WaitForGPUIdle(GPUDeviceHandle device) => + (MaybeBool)(byte)WaitForGPUIdleRaw(device); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitForGPUIdle")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CaptureMouse([NativeTypeName("bool")] byte enabled) => T.CaptureMouse(enabled); + public static extern byte WaitForGPUIdleRaw(GPUDeviceHandle device); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitProcess")] + [return: NativeTypeName("bool")] + public static extern byte WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => - T.CaptureMouse(enabled); + public static MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ) + { + fixed (int* __dsl_exitcode = exitcode) + { + return (MaybeBool)(byte)WaitProcess(process, (byte)block, __dsl_exitcode); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void CleanupTLS() => T.CleanupTLS(); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitSemaphore")] + public static extern void WaitSemaphore(SemaphoreHandle sem); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool ClearAudioStream(AudioStreamHandle stream) => - T.ClearAudioStream(stream); + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + public static MaybeBool WaitSemaphoreTimeout( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ) => (MaybeBool)(byte)WaitSemaphoreTimeoutRaw(sem, timeoutMS); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitSemaphoreTimeout")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ClearAudioStreamRaw(AudioStreamHandle stream) => T.ClearAudioStreamRaw(stream); + public static extern byte WaitSemaphoreTimeoutRaw( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WaitThread")] + public static extern void WaitThread(ThreadHandle thread, int* status); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ClearClipboardData() => T.ClearClipboardData(); + public static void WaitThread(ThreadHandle thread, Ref status) + { + fixed (int* __dsl_status = status) + { + WaitThread(thread, __dsl_status); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ClearClipboardDataRaw() => T.ClearClipboardDataRaw(); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + public static MaybeBool WarpMouseGlobal(float x, float y) => + (MaybeBool)(byte)WarpMouseGlobalRaw(x, y); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WarpMouseGlobal")] [return: NativeTypeName("bool")] + public static extern byte WarpMouseGlobalRaw(float x, float y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WarpMouseInWindow")] + public static extern void WarpMouseInWindow(WindowHandle window, float x, float y); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WasInit")] + [return: NativeTypeName("SDL_InitFlags")] + public static extern uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcscasecmp")] + public static extern int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ClearComposition(WindowHandle window) => T.ClearComposition(window); + public static int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcscasecmp(__dsl_str1, __dsl_str2); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcscmp")] + public static extern int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ClearCompositionRaw(WindowHandle window) => T.ClearCompositionRaw(window); + public static int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcscmp(__dsl_str1, __dsl_str2); + } + } - [return: NativeTypeName("bool")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsdup")] + [return: NativeTypeName("wchar_t *")] + public static extern uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr); + + [return: NativeTypeName("wchar_t *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ClearError() => T.ClearError(); + public static Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (uint*)Wcsdup(__dsl_wstr); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcslcat")] + [return: NativeTypeName("size_t")] + public static extern nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ClearErrorRaw() => T.ClearErrorRaw(); + public static nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)Wcslcat(__dsl_dst, __dsl_src, maxlen); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => T.ClearProperty(props, name); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcslcpy")] + [return: NativeTypeName("size_t")] + public static extern nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) => T.ClearProperty(props, name); + public static nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)Wcslcpy(__dsl_dst, __dsl_src, maxlen); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ClearSurface(Surface* surface, float r, float g, float b, float a) => - T.ClearSurface(surface, r, g, b, a); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcslen")] + [return: NativeTypeName("size_t")] + public static extern nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ClearSurface( - Ref surface, - float r, - float g, - float b, - float a - ) => T.ClearSurface(surface, r, g, b, a); + public static nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)Wcslen(__dsl_wstr); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - T.CloseAudioDevice(devid); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsncasecmp")] + public static extern int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void CloseCamera(CameraHandle camera) => T.CloseCamera(camera); + public static int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcsncasecmp(__dsl_str1, __dsl_str2, maxlen); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void CloseGamepad(GamepadHandle gamepad) => T.CloseGamepad(gamepad); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsncmp")] + public static extern int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void CloseHaptic(HapticHandle haptic) => T.CloseHaptic(haptic); + public static int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcsncmp(__dsl_str1, __dsl_str2, maxlen); + } + } - [return: NativeTypeName("bool")] + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsnlen")] + [return: NativeTypeName("size_t")] + public static extern nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ); + + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CloseIO(IOStreamHandle context) => T.CloseIO(context); + public static nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)Wcsnlen(__dsl_wstr, maxlen); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CloseIORaw(IOStreamHandle context) => T.CloseIORaw(context); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsnstr")] + [return: NativeTypeName("wchar_t *")] + public static extern uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void CloseJoystick(JoystickHandle joystick) => T.CloseJoystick(joystick); + public static Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)Wcsnstr(__dsl_haystack, __dsl_needle, maxlen); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void CloseSensor(SensorHandle sensor) => T.CloseSensor(sensor); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcsstr")] + [return: NativeTypeName("wchar_t *")] + public static extern uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ); - [return: NativeTypeName("bool")] + [return: NativeTypeName("wchar_t *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CloseStorage(StorageHandle storage) => T.CloseStorage(storage); + public static Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)Wcsstr(__dsl_haystack, __dsl_needle); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CloseStorageRaw(StorageHandle storage) => T.CloseStorageRaw(storage); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_wcstol")] + [return: NativeTypeName("long")] + public static extern nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => - T.CompareAndSwapAtomicInt(a, oldval, newval); + public static nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ) + { + fixed (uint** __dsl_endp = endp) + fixed (uint* __dsl_str = str) + { + return (nint)Wcstol(__dsl_str, __dsl_endp, @base); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool CompareAndSwapAtomicInt(Ref a, int oldval, int newval) => - T.CompareAndSwapAtomicInt(a, oldval, newval); + [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + public static MaybeBool WindowHasSurface(WindowHandle window) => + (MaybeBool)(byte)WindowHasSurfaceRaw(window); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WindowHasSurface")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => - T.CompareAndSwapAtomicPointer(a, oldval, newval); + public static extern byte WindowHasSurfaceRaw(WindowHandle window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) => - T.CompareAndSwapAtomicPointer(a, oldval, newval); + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + public static MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => (MaybeBool)(byte)WindowSupportsGPUPresentModeRaw(device, window, present_mode); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WindowSupportsGPUPresentMode")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CompareAndSwapAtomicU32( - AtomicU32* a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => T.CompareAndSwapAtomicU32(a, oldval, newval); + public static extern byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool CompareAndSwapAtomicU32( - Ref a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => T.CompareAndSwapAtomicU32(a, oldval, newval); - - [return: NativeTypeName("SDL_BlendMode")] - [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public uint ComposeCustomBlendMode( - BlendFactor srcColorFactor, - BlendFactor dstColorFactor, - BlendOperation colorOperation, - BlendFactor srcAlphaFactor, - BlendFactor dstAlphaFactor, - BlendOperation alphaOperation + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + public static MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition ) => - T.ComposeCustomBlendMode( - srcColorFactor, - dstColorFactor, - colorOperation, - srcAlphaFactor, - dstAlphaFactor, - alphaOperation - ); + (MaybeBool) + (byte)WindowSupportsGPUSwapchainCompositionRaw( + device, + window, + swapchain_composition + ); + [DllImport( + "SDL3", + ExactSpelling = true, + EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition" + )] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + public static extern byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteIO")] + [return: NativeTypeName("size_t")] + public static extern nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] void* ptr, + [NativeTypeName("size_t")] nuint size + ); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const Uint8 *")] byte* src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, - [NativeTypeName("Uint8 **")] byte** dst_data, - int* dst_len - ) => T.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + public static nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] Ref ptr, + [NativeTypeName("size_t")] nuint size + ) + { + fixed (void* __dsl_ptr = ptr) + { + return (nuint)WriteIO(context, __dsl_ptr, size); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const Uint8 *")] Ref src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, - [NativeTypeName("Uint8 **")] Ref2D dst_data, - Ref dst_len - ) => T.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + public static MaybeBool WriteS16BE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => (MaybeBool)(byte)WriteS16BERaw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS16BE")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => - T.ConvertEventToRenderCoordinates(renderer, @event); + public static extern byte WriteS16BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool ConvertEventToRenderCoordinates( - RendererHandle renderer, - Ref @event - ) => T.ConvertEventToRenderCoordinates(renderer, @event); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + public static MaybeBool WriteS16LE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => (MaybeBool)(byte)WriteS16LERaw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS16LE")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch - ) => T.ConvertPixels(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); + public static extern byte WriteS16LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch - ) => T.ConvertPixels(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + public static MaybeBool WriteS32BE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => (MaybeBool)(byte)WriteS32BERaw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS32BE")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - void* dst, - int dst_pitch - ) => - T.ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + public static extern byte WriteS32BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - Ref dst, - int dst_pitch - ) => - T.ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + public static MaybeBool WriteS32LE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => (MaybeBool)(byte)WriteS32LERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Surface* ConvertSurface(Surface* surface, PixelFormat format) => - T.ConvertSurface(surface, format); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS32LE")] + [return: NativeTypeName("bool")] + public static extern byte WriteS32LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Ptr ConvertSurface(Ref surface, PixelFormat format) => - T.ConvertSurface(surface, format); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + public static MaybeBool WriteS64BE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => (MaybeBool)(byte)WriteS64BERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Surface* ConvertSurfaceAndColorspace( - Surface* surface, - PixelFormat format, - Palette* palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS64BE")] + [return: NativeTypeName("bool")] + public static extern byte WriteS64BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Ptr ConvertSurfaceAndColorspace( - Ref surface, - PixelFormat format, - Ref palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + public static MaybeBool WriteS64LE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => (MaybeBool)(byte)WriteS64LERaw(dst, value); + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS64LE")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte CopyFile( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => T.CopyFile(oldpath, newpath); + public static extern byte WriteS64LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool CopyFile( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => T.CopyFile(oldpath, newpath); + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + public static MaybeBool WriteS8( + IOStreamHandle dst, + [NativeTypeName("Sint8")] sbyte value + ) => (MaybeBool)(byte)WriteS8Raw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteS8")] + [return: NativeTypeName("bool")] + public static extern byte WriteS8Raw( + IOStreamHandle dst, + [NativeTypeName("Sint8")] sbyte value + ); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteStorageFile")] + [return: NativeTypeName("bool")] + public static extern byte WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const void *")] void* source, + [NativeTypeName("Uint64")] ulong length + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CopyProperties( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => T.CopyProperties(src, dst); + public static MaybeBool WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const void *")] Ref source, + [NativeTypeName("Uint64")] ulong length + ) + { + fixed (void* __dsl_source = source) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)WriteStorageFile(storage, __dsl_path, __dsl_source, length); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteSurfacePixel")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + public static extern byte WriteSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CopyPropertiesRaw( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => T.CopyPropertiesRaw(src, dst); + public static MaybeBool WriteSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)WriteSurfacePixel(__dsl_surface, x, y, r, g, b, a); + } + } + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteSurfacePixelFloat")] [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + public static extern byte WriteSurfacePixelFloat( + Surface* surface, + int x, + int y, + float r, + float g, + float b, + float a + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => T.CopyStorageFile(storage, oldpath, newpath); + public static MaybeBool WriteSurfacePixelFloat( + Ref surface, + int x, + int y, + float r, + float g, + float b, + float a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)WriteSurfacePixelFloat(__dsl_surface, x, y, r, g, b, a); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + public static MaybeBool WriteU16BE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => (MaybeBool)(byte)WriteU16BERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU16BE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU16BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + public static MaybeBool WriteU16LE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => (MaybeBool)(byte)WriteU16LERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU16LE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU16LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + public static MaybeBool WriteU32BE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => (MaybeBool)(byte)WriteU32BERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU32BE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU32BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + public static MaybeBool WriteU32LE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => (MaybeBool)(byte)WriteU32LERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU32LE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU32LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + public static MaybeBool WriteU64BE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => (MaybeBool)(byte)WriteU64BERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU64BE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU64BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + public static MaybeBool WriteU64LE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => (MaybeBool)(byte)WriteU64LERaw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU64LE")] + [return: NativeTypeName("bool")] + public static extern byte WriteU64LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + public static MaybeBool WriteU8( + IOStreamHandle dst, + [NativeTypeName("Uint8")] byte value + ) => (MaybeBool)(byte)WriteU8Raw(dst, value); + + [DllImport("SDL3", ExactSpelling = true, EntryPoint = "SDL_WriteU8")] + [return: NativeTypeName("bool")] + public static extern byte WriteU8Raw( + IOStreamHandle dst, + [NativeTypeName("Uint8")] byte value + ); + } + + public partial class StaticWrapper : ISdl + where T : ISdl.Static + { + [NativeFunction("SDL3", EntryPoint = "SDL_abs")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => T.CopyStorageFile(storage, oldpath, newpath); + public int Abs(int x) => T.Abs(x); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_acos")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => T.CreateAudioStream(src_spec, dst_spec); + public double Acos(double x) => T.Acos(x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_acosf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) => T.CreateAudioStream(src_spec, dst_spec); + public float Acosf(float x) => T.Acosf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => - T.CreateColorCursor(surface, hot_x, hot_y); + public Surface* AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] ulong* timestampNS + ) => T.AcquireCameraFrame(camera, timestampNS); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) => - T.CreateColorCursor(surface, hot_x, hot_y); + public Ptr AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] Ref timestampNS + ) => T.AcquireCameraFrame(camera, timestampNS); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ConditionHandle CreateCondition() => T.CreateCondition(); + public GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device) => + T.AcquireGPUCommandBuffer(device); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] byte* data, - [NativeTypeName("const Uint8 *")] byte* mask, - int w, - int h, - int hot_x, - int hot_y - ) => T.CreateCursor(data, mask, w, h, hot_x, hot_y); + public byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ) => + T.AcquireGPUSwapchainTexture( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] Ref data, - [NativeTypeName("const Uint8 *")] Ref mask, - int w, - int h, - int hot_x, - int hot_y - ) => T.CreateCursor(data, mask, w, h, hot_x, hot_y); + public MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ) => + T.AcquireGPUSwapchainTexture( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => - T.CreateDirectory(path); + public int AddAtomicInt(AtomicInt* a, int v) => T.AddAtomicInt(a, v); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CreateDirectory([NativeTypeName("const char *")] Ref path) => - T.CreateDirectory(path); + public int AddAtomicInt(Ref a, int v) => T.AddAtomicInt(a, v); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => T.CreateHapticEffect(haptic, effect); + public byte AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => T.AddEventWatch(filter, userdata); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) => T.CreateHapticEffect(haptic, effect); + public MaybeBool AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => T.AddEventWatch(filter, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MutexHandle CreateMutex() => T.CreateMutex(); + public int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => + T.AddGamepadMapping(mapping); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreatePalette(int ncolors) => T.CreatePalette(ncolors); + public int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) => + T.AddGamepadMapping(mapping); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Palette* CreatePaletteRaw(int ncolors) => T.CreatePaletteRaw(ncolors); + public int AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => + T.AddGamepadMappingsFromFile(file); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle CreatePopupWindow( - WindowHandle parent, - int offset_x, - int offset_y, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => T.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); + public int AddGamepadMappingsFromFile([NativeTypeName("const char *")] Ref file) => + T.AddGamepadMappingsFromFile(file); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint CreateProperties() => T.CreateProperties(); + public int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio + ) => T.AddGamepadMappingsFromIO(src, closeio); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* name - ) => T.CreateRenderer(window, name); + public int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => T.AddGamepadMappingsFromIO(src, closeio); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] Ref name - ) => T.CreateRenderer(window, name); + public byte AddHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => T.AddHintCallback(name, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle CreateRendererWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.CreateRendererWithProperties(props); + public MaybeBool AddHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) => T.AddHintCallback(name, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RWLockHandle CreateRWLock() => T.CreateRWLock(); + public byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => + T.AddSurfaceAlternateImage(surface, image); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SemaphoreHandle CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => - T.CreateSemaphore(initial_value); + public MaybeBool AddSurfaceAlternateImage(Ref surface, Ref image) => + T.AddSurfaceAlternateImage(surface, image); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle CreateSoftwareRenderer(Surface* surface) => - T.CreateSoftwareRenderer(surface); + public uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + void* userdata + ) => T.AddTimer(interval, callback, userdata); + [return: NativeTypeName("SDL_TimerID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle CreateSoftwareRenderer(Ref surface) => - T.CreateSoftwareRenderer(surface); + public uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + Ref userdata + ) => T.AddTimer(interval, callback, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => T.CreateStorageDirectory(storage, path); + public uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + void* userdata + ) => T.AddTimerNS(interval, callback, userdata); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_TimerID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) => T.CreateStorageDirectory(storage, path); + public uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + Ref userdata + ) => T.AddTimerNS(interval, callback, userdata); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateSurface(int width, int height, PixelFormat format) => - T.CreateSurface(width, height, format); + public MaybeBool AddVulkanRenderSemaphores( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + T.AddVulkanRenderSemaphores( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - void* pixels, - int pitch - ) => T.CreateSurfaceFrom(width, height, format, pixels, pitch); + public byte AddVulkanRenderSemaphoresRaw( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + T.AddVulkanRenderSemaphoresRaw( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - Ref pixels, - int pitch - ) => T.CreateSurfaceFrom(width, height, format, pixels, pitch); + public Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => T.AlignedAlloc(alignment, size); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Palette* CreateSurfacePalette(Surface* surface) => T.CreateSurfacePalette(surface); + public void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => T.AlignedAllocRaw(alignment, size); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateSurfacePalette(Ref surface) => - T.CreateSurfacePalette(surface); + public void AlignedFree(void* mem) => T.AlignedFree(mem); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => - T.CreateSurfaceRaw(width, height, format); + public void AlignedFree(Ref mem) => T.AlignedFree(mem); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_asin")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle CreateSystemCursor(SystemCursor id) => T.CreateSystemCursor(id); + public double Asin(double x) => T.Asin(x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_asinf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateTexture( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => T.CreateTexture(renderer, format, access, w, h); + public float Asinf(float x) => T.Asinf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_atan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Texture* CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => - T.CreateTextureFromSurface(renderer, surface); + public double Atan(double x) => T.Atan(x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_atan2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateTextureFromSurface( - RendererHandle renderer, - Ref surface - ) => T.CreateTextureFromSurface(renderer, surface); + public double Atan2(double y, double x) => T.Atan2(y, x); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_atan2f")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Texture* CreateTextureRaw( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => T.CreateTextureRaw(renderer, format, access, w, h); + public float Atan2F(float y, float x) => T.Atan2F(y, x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_atanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr CreateTextureWithProperties( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.CreateTextureWithProperties(renderer, props); - - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Texture* CreateTextureWithPropertiesRaw( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.CreateTextureWithPropertiesRaw(renderer, props); + public float Atanf(float x) => T.Atanf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] sbyte* name, - void* data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => T.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); + public double Atof([NativeTypeName("const char *")] sbyte* str) => T.Atof(str); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] Ref name, - Ref data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => T.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); - - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ThreadHandle CreateThreadWithPropertiesRuntime( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => T.CreateThreadWithPropertiesRuntime(props, pfnBeginThread, pfnEndThread); + public double Atof([NativeTypeName("const char *")] Ref str) => T.Atof(str); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle CreateWindow( - [NativeTypeName("const char *")] sbyte* title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => T.CreateWindow(title, w, h, flags); + public int Atoi([NativeTypeName("const char *")] sbyte* str) => T.Atoi(str); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle CreateWindow( - [NativeTypeName("const char *")] Ref title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => T.CreateWindow(title, w, h, flags); + public int Atoi([NativeTypeName("const char *")] Ref str) => T.Atoi(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CreateWindowAndRenderer( - [NativeTypeName("const char *")] sbyte* title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - WindowHandle* window, - RendererHandle* renderer - ) => T.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); + public uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + ) => T.AttachVirtualJoystick(desc); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_JoystickID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool CreateWindowAndRenderer( - [NativeTypeName("const char *")] Ref title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - Ref window, - Ref renderer - ) => T.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); - - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle CreateWindowWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.CreateWindowWithProperties(props); + public uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + ) => T.AttachVirtualJoystick(desc); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool CursorVisible() => T.CursorVisible(); + public MaybeBool AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.AudioDevicePaused(dev); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte CursorVisibleRaw() => T.CursorVisibleRaw(); + public byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.AudioDevicePausedRaw(dev); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] DateTime* dt, - [NativeTypeName("SDL_Time *")] long* ticks - ) => T.DateTimeToTime(dt, ticks); + public GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + T.BeginGPUComputePass( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] Ref dt, - [NativeTypeName("SDL_Time *")] Ref ticks - ) => T.DateTimeToTime(dt, ticks); + public GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + T.BeginGPUComputePass( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUCopyPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void Delay([NativeTypeName("Uint32")] uint ms) => T.Delay(ms); + public GPUCopyPassHandle BeginGPUCopyPass(GPUCommandBufferHandle command_buffer) => + T.BeginGPUCopyPass(command_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DelayNS([NativeTypeName("Uint64")] ulong ns) => T.DelayNS(ns); + public GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ) => + T.BeginGPURenderPass( + command_buffer, + color_target_infos, + num_color_targets, + depth_stencil_target_info + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => T.DelayPrecise(ns); + public GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ) => + T.BeginGPURenderPass( + command_buffer, + color_target_infos, + num_color_targets, + depth_stencil_target_info + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyAudioStream(AudioStreamHandle stream) => T.DestroyAudioStream(stream); + public MaybeBool BindAudioStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => T.BindAudioStream(devid, stream); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyCondition(ConditionHandle cond) => T.DestroyCondition(cond); + public byte BindAudioStreamRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => T.BindAudioStreamRaw(devid, stream); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyCursor(CursorHandle cursor) => T.DestroyCursor(cursor); + public byte BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle* streams, + int num_streams + ) => T.BindAudioStreams(devid, streams, num_streams); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyHapticEffect(HapticHandle haptic, int effect) => - T.DestroyHapticEffect(haptic, effect); + public MaybeBool BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref streams, + int num_streams + ) => T.BindAudioStreams(devid, streams, num_streams); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyMutex(MutexHandle mutex) => T.DestroyMutex(mutex); + public void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ) => T.BindGPUComputePipeline(compute_pass, compute_pipeline); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyPalette(Palette* palette) => T.DestroyPalette(palette); + public void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeSamplers( + compute_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyPalette(Ref palette) => T.DestroyPalette(palette); + public void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeSamplers( + compute_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - T.DestroyProperties(props); + public void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeStorageBuffers(compute_pass, first_slot, storage_buffers, num_bindings); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyRenderer(RendererHandle renderer) => T.DestroyRenderer(renderer); + public void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeStorageBuffers(compute_pass, first_slot, storage_buffers, num_bindings); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyRWLock(RWLockHandle rwlock) => T.DestroyRWLock(rwlock); + public void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeStorageTextures( + compute_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroySemaphore(SemaphoreHandle sem) => T.DestroySemaphore(sem); + public void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUComputeStorageTextures( + compute_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroySurface(Surface* surface) => T.DestroySurface(surface); + public void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroySurface(Ref surface) => T.DestroySurface(surface); + public void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyTexture(Texture* texture) => T.DestroyTexture(texture); + public void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentStorageBuffers(render_pass, first_slot, storage_buffers, num_bindings); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyTexture(Ref texture) => T.DestroyTexture(texture); + public void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentStorageBuffers(render_pass, first_slot, storage_buffers, num_bindings); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DestroyWindow(WindowHandle window) => T.DestroyWindow(window); + public void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool DestroyWindowSurface(WindowHandle window) => - T.DestroyWindowSurface(window); + public void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUFragmentStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte DestroyWindowSurfaceRaw(WindowHandle window) => - T.DestroyWindowSurfaceRaw(window); + public void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ) => T.BindGPUGraphicsPipeline(render_pass, graphics_pipeline); - [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void DetachThread(ThreadHandle thread) => T.DetachThread(thread); + public void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ) => T.BindGPUIndexBuffer(render_pass, binding, index_element_size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool DetachVirtualJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.DetachVirtualJoystick(instance_id); + public void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ) => T.BindGPUIndexBuffer(render_pass, binding, index_element_size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte DetachVirtualJoystickRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.DetachVirtualJoystickRaw(instance_id); + public void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => T.BindGPUVertexBuffers(render_pass, first_slot, bindings, num_bindings); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool DisableScreenSaver() => T.DisableScreenSaver(); + public void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => T.BindGPUVertexBuffers(render_pass, first_slot, bindings, num_bindings); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte DisableScreenSaverRaw() => T.DisableScreenSaverRaw(); + public void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUVertexSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* DuplicateSurface(Surface* surface) => T.DuplicateSurface(surface); + public void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUVertexSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr DuplicateSurface(Ref surface) => T.DuplicateSurface(surface); + public void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => T.BindGPUVertexStorageBuffers(render_pass, first_slot, storage_buffers, num_bindings); - [return: NativeTypeName("SDL_EGLConfig")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr EGLGetCurrentConfig() => T.EGLGetCurrentConfig(); + public void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => T.BindGPUVertexStorageBuffers(render_pass, first_slot, storage_buffers, num_bindings); - [return: NativeTypeName("SDL_EGLConfig")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* EGLGetCurrentConfigRaw() => T.EGLGetCurrentConfigRaw(); + public void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUVertexStorageTextures(render_pass, first_slot, storage_textures, num_bindings); - [return: NativeTypeName("SDL_EGLDisplay")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr EGLGetCurrentDisplay() => T.EGLGetCurrentDisplay(); - - [return: NativeTypeName("SDL_EGLDisplay")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void* EGLGetCurrentDisplayRaw() => T.EGLGetCurrentDisplayRaw(); + public void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + T.BindGPUVertexStorageTextures(render_pass, first_slot, storage_textures, num_bindings); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => - T.EGLGetProcAddress(proc); + public void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ) => T.BlitGPUTexture(command_buffer, info); - [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer EGLGetProcAddress( - [NativeTypeName("const char *")] Ref proc - ) => T.EGLGetProcAddress(proc); + public void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info + ) => T.BlitGPUTexture(command_buffer, info); - [return: NativeTypeName("SDL_EGLSurface")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr EGLGetWindowSurface(WindowHandle window) => T.EGLGetWindowSurface(window); + public byte BlitSurface( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => T.BlitSurface(src, srcrect, dst, dstrect); - [return: NativeTypeName("SDL_EGLSurface")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* EGLGetWindowSurfaceRaw(WindowHandle window) => - T.EGLGetWindowSurfaceRaw(window); + public MaybeBool BlitSurface( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => T.BlitSurface(src, srcrect, dst, dstrect); - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - void* userdata + public byte BlitSurface9Grid( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect ) => - T.EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - userdata + T.BlitSurface9Grid( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - Ref userdata + public MaybeBool BlitSurface9Grid( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect ) => - T.EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - userdata + T.BlitSurface9Grid( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect ); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool EnableScreenSaver() => T.EnableScreenSaver(); + public byte BlitSurfaceScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => T.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte EnableScreenSaverRaw() => T.EnableScreenSaverRaw(); + public MaybeBool BlitSurfaceScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) => T.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte EnumerateDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => T.EnumerateDirectory(path, callback, userdata); + public byte BlitSurfaceTiled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => T.BlitSurfaceTiled(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool EnumerateDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) => T.EnumerateDirectory(path, callback, userdata); + public MaybeBool BlitSurfaceTiled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => T.BlitSurfaceTiled(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] - EnumeratePropertiesCallback callback, - void* userdata - ) => T.EnumerateProperties(props, callback, userdata); + public byte BlitSurfaceTiledWithScale( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => T.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] - EnumeratePropertiesCallback callback, - Ref userdata - ) => T.EnumerateProperties(props, callback, userdata); + public MaybeBool BlitSurfaceTiledWithScale( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => T.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => T.EnumerateStorageDirectory(storage, path, callback, userdata); + public byte BlitSurfaceUnchecked( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => T.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) => T.EnumerateStorageDirectory(storage, path, callback, userdata); + public MaybeBool BlitSurfaceUnchecked( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => T.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => - T.EventEnabled(type); + public byte BlitSurfaceUncheckedScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => T.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => - T.EventEnabledRaw(type); + public MaybeBool BlitSurfaceUncheckedScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) => T.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FillSurfaceRect( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("Uint32")] uint color - ) => T.FillSurfaceRect(dst, rect, color); + public void BroadcastCondition(ConditionHandle cond) => T.BroadcastCondition(cond); + + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => T.Bsearch(key, @base, nmemb, size, compare); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FillSurfaceRect( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("Uint32")] uint color - ) => T.FillSurfaceRect(dst, rect, color); + public Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => T.Bsearch(key, @base, nmemb, size, compare); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FillSurfaceRects( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => T.FillSurfaceRects(dst, rects, count, color); + public void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => T.BsearchR(key, @base, nmemb, size, compare, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FillSurfaceRects( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => T.FillSurfaceRects(dst, rects, count, color); + public Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) => T.BsearchR(key, @base, nmemb, size, compare, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CalculateGPUTextureFormatSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => T.FilterEvents(filter, userdata); + public uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ) => T.CalculateGPUTextureFormatSize(format, width, height, depth_or_layer_count); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => T.FilterEvents(filter, userdata); + public Ptr Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => T.Calloc(nmemb, size); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => - T.FlashWindow(window, operation); + public void* CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => T.CallocRaw(nmemb, size); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => - T.FlashWindowRaw(window, operation); + public MaybeBool CancelGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + T.CancelGPUCommandBuffer(command_buffer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FlipSurface(Surface* surface, FlipMode flip) => T.FlipSurface(surface, flip); + public byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + T.CancelGPUCommandBufferRaw(command_buffer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FlipSurface(Ref surface, FlipMode flip) => - T.FlipSurface(surface, flip); + public byte CaptureMouse([NativeTypeName("bool")] byte enabled) => T.CaptureMouse(enabled); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FlushAudioStream(AudioStreamHandle stream) => - T.FlushAudioStream(stream); + public MaybeBool CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => + T.CaptureMouse(enabled); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_ceil")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FlushAudioStreamRaw(AudioStreamHandle stream) => T.FlushAudioStreamRaw(stream); + public double Ceil(double x) => T.Ceil(x); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_ceilf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void FlushEvent([NativeTypeName("Uint32")] uint type) => T.FlushEvent(type); + public float Ceilf(float x) => T.Ceilf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void FlushEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => T.FlushEvents(minType, maxType); + public MaybeBool ClaimWindowForGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ) => T.ClaimWindowForGPUDevice(device, window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FlushIO(IOStreamHandle context) => T.FlushIO(context); + public byte ClaimWindowForGPUDeviceRaw(GPUDeviceHandle device, WindowHandle window) => + T.ClaimWindowForGPUDeviceRaw(device, window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FlushIORaw(IOStreamHandle context) => T.FlushIORaw(context); + public void CleanupTLS() => T.CleanupTLS(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool FlushRenderer(RendererHandle renderer) => T.FlushRenderer(renderer); + public MaybeBool ClearAudioStream(AudioStreamHandle stream) => + T.ClearAudioStream(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte FlushRendererRaw(RendererHandle renderer) => T.FlushRendererRaw(renderer); + public byte ClearAudioStreamRaw(AudioStreamHandle stream) => T.ClearAudioStreamRaw(stream); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadConnected(GamepadHandle gamepad) => - T.GamepadConnected(gamepad); + public MaybeBool ClearClipboardData() => T.ClearClipboardData(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadConnectedRaw(GamepadHandle gamepad) => T.GamepadConnectedRaw(gamepad); + public byte ClearClipboardDataRaw() => T.ClearClipboardDataRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadEventsEnabled() => T.GamepadEventsEnabled(); + public MaybeBool ClearComposition(WindowHandle window) => T.ClearComposition(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadEventsEnabledRaw() => T.GamepadEventsEnabledRaw(); + public byte ClearCompositionRaw(WindowHandle window) => T.ClearCompositionRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => - T.GamepadHasAxis(gamepad, axis); + public MaybeBool ClearError() => T.ClearError(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => - T.GamepadHasAxisRaw(gamepad, axis); + public byte ClearErrorRaw() => T.ClearErrorRaw(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => T.ClearProperty(props, name); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => - T.GamepadHasButton(gamepad, button); + public MaybeBool ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => T.ClearProperty(props, name); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => - T.GamepadHasButtonRaw(gamepad, button); + public byte ClearSurface(Surface* surface, float r, float g, float b, float a) => + T.ClearSurface(surface, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => - T.GamepadHasSensor(gamepad, type); + public MaybeBool ClearSurface( + Ref surface, + float r, + float g, + float b, + float a + ) => T.ClearSurface(surface, r, g, b, a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => - T.GamepadHasSensorRaw(gamepad, type); + public void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + T.CloseAudioDevice(devid); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => - T.GamepadSensorEnabled(gamepad, type); + public void CloseCamera(CameraHandle camera) => T.CloseCamera(camera); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => - T.GamepadSensorEnabledRaw(gamepad, type); + public void CloseGamepad(GamepadHandle gamepad) => T.CloseGamepad(gamepad); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => - T.GetAppMetadataProperty(name); + public void CloseHaptic(HapticHandle haptic) => T.CloseHaptic(haptic); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name - ) => T.GetAppMetadataProperty(name); + public MaybeBool CloseIO(IOStreamHandle context) => T.CloseIO(context); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertionHandler GetAssertionHandler(void** puserdata) => - T.GetAssertionHandler(puserdata); + public byte CloseIORaw(IOStreamHandle context) => T.CloseIORaw(context); - [return: NativeTypeName("SDL_AssertionHandler")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertionHandler GetAssertionHandler(Ref2D puserdata) => - T.GetAssertionHandler(puserdata); + public void CloseJoystick(JoystickHandle joystick) => T.CloseJoystick(joystick); - [return: NativeTypeName("const SDL_AssertData *")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void CloseSensor(SensorHandle sensor) => T.CloseSensor(sensor); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAssertionReport() => T.GetAssertionReport(); + public MaybeBool CloseStorage(StorageHandle storage) => T.CloseStorage(storage); - [return: NativeTypeName("const SDL_AssertData *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertData* GetAssertionReportRaw() => T.GetAssertionReportRaw(); + public byte CloseStorageRaw(StorageHandle storage) => T.CloseStorageRaw(storage); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAtomicInt(AtomicInt* a) => T.GetAtomicInt(a); + public byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => + T.CompareAndSwapAtomicInt(a, oldval, newval); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAtomicInt(Ref a) => T.GetAtomicInt(a); + public MaybeBool CompareAndSwapAtomicInt(Ref a, int oldval, int newval) => + T.CompareAndSwapAtomicInt(a, oldval, newval); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetAtomicPointer(void** a) => T.GetAtomicPointer(a); + public byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => + T.CompareAndSwapAtomicPointer(a, oldval, newval); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAtomicPointer(Ref2D a) => T.GetAtomicPointer(a); + public MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) => + T.CompareAndSwapAtomicPointer(a, oldval, newval); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetAtomicU32(AtomicU32* a) => T.GetAtomicU32(a); + public byte CompareAndSwapAtomicU32( + AtomicU32* a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => T.CompareAndSwapAtomicU32(a, oldval, newval); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetAtomicU32(Ref a) => T.GetAtomicU32(a); + public MaybeBool CompareAndSwapAtomicU32( + Ref a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => T.CompareAndSwapAtomicU32(a, oldval, newval); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [return: NativeTypeName("SDL_BlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int* GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - int* count - ) => T.GetAudioDeviceChannelMap(devid, count); + public uint ComposeCustomBlendMode( + BlendFactor srcColorFactor, + BlendFactor dstColorFactor, + BlendOperation colorOperation, + BlendFactor srcAlphaFactor, + BlendFactor dstAlphaFactor, + BlendOperation alphaOperation + ) => + T.ComposeCustomBlendMode( + srcColorFactor, + dstColorFactor, + colorOperation, + srcAlphaFactor, + dstAlphaFactor, + alphaOperation + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const Uint8 *")] byte* src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, + [NativeTypeName("Uint8 **")] byte** dst_data, + int* dst_len + ) => T.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref count - ) => T.GetAudioDeviceChannelMap(devid, count); + public MaybeBool ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const Uint8 *")] Ref src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, + [NativeTypeName("Uint8 **")] Ref2D dst_data, + Ref dst_len + ) => T.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioSpec* spec, - int* sample_frames - ) => T.GetAudioDeviceFormat(devid, spec, sample_frames); + public byte ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => + T.ConvertEventToRenderCoordinates(renderer, @event); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref spec, - Ref sample_frames - ) => T.GetAudioDeviceFormat(devid, spec, sample_frames); + public MaybeBool ConvertEventToRenderCoordinates( + RendererHandle renderer, + Ref @event + ) => T.ConvertEventToRenderCoordinates(renderer, @event); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - T.GetAudioDeviceGain(devid); + public byte ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch + ) => T.ConvertPixels(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - T.GetAudioDeviceName(devid); + public MaybeBool ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch + ) => T.ConvertPixels(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - T.GetAudioDeviceNameRaw(devid); + public byte ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + void* dst, + int dst_pitch + ) => + T.ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioDriver(int index) => T.GetAudioDriver(index); + public MaybeBool ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + Ref dst, + int dst_pitch + ) => + T.ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetAudioDriverRaw(int index) => T.GetAudioDriverRaw(index); + public Surface* ConvertSurface(Surface* surface, PixelFormat format) => + T.ConvertSurface(surface, format); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioFormatName(AudioFormat format) => T.GetAudioFormatName(format); + public Ptr ConvertSurface(Ref surface, PixelFormat format) => + T.ConvertSurface(surface, format); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetAudioFormatNameRaw(AudioFormat format) => T.GetAudioFormatNameRaw(format); + public Surface* ConvertSurfaceAndColorspace( + Surface* surface, + PixelFormat format, + Palette* palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetAudioPlaybackDevices(int* count) => T.GetAudioPlaybackDevices(count); + public Ptr ConvertSurfaceAndColorspace( + Ref surface, + PixelFormat format, + Ref palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); - [return: NativeTypeName("SDL_AudioDeviceID *")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte CopyFile( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => T.CopyFile(oldpath, newpath); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioPlaybackDevices(Ref count) => - T.GetAudioPlaybackDevices(count); + public MaybeBool CopyFile( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => T.CopyFile(oldpath, newpath); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetAudioRecordingDevices(int* count) => T.GetAudioRecordingDevices(count); + public void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ) => T.CopyGPUBufferToBuffer(copy_pass, source, destination, size, cycle); - [return: NativeTypeName("SDL_AudioDeviceID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioRecordingDevices(Ref count) => - T.GetAudioRecordingDevices(count); + public void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ) => T.CopyGPUBufferToBuffer(copy_pass, source, destination, size, cycle); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAudioStreamAvailable(AudioStreamHandle stream) => - T.GetAudioStreamAvailable(stream); + public void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ) => T.CopyGPUTextureToTexture(copy_pass, source, destination, w, h, d, cycle); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => - T.GetAudioStreamData(stream, buf, len); + public void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ) => T.CopyGPUTextureToTexture(copy_pass, source, destination, w, h, d, cycle); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) => - T.GetAudioStreamData(stream, buf, len); - - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public uint GetAudioStreamDevice(AudioStreamHandle stream) => - T.GetAudioStreamDevice(stream); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte GetAudioStreamFormat( - AudioStreamHandle stream, - AudioSpec* src_spec, - AudioSpec* dst_spec - ) => T.GetAudioStreamFormat(stream, src_spec, dst_spec); + public MaybeBool CopyProperties( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => T.CopyProperties(src, dst); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetAudioStreamFormat( - AudioStreamHandle stream, - Ref src_spec, - Ref dst_spec - ) => T.GetAudioStreamFormat(stream, src_spec, dst_spec); + public byte CopyPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => T.CopyPropertiesRaw(src, dst); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_copysign")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => - T.GetAudioStreamFrequencyRatio(stream); + public double Copysign(double x, double y) => T.Copysign(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_copysignf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetAudioStreamGain(AudioStreamHandle stream) => T.GetAudioStreamGain(stream); + public float Copysignf(float x, float y) => T.Copysignf(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => - T.GetAudioStreamInputChannelMap(stream, count); + public byte CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => T.CopyStorageFile(storage, oldpath, newpath); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Ptr GetAudioStreamInputChannelMap(AudioStreamHandle stream, Ref count) => - T.GetAudioStreamInputChannelMap(stream, count); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => - T.GetAudioStreamOutputChannelMap(stream, count); + public MaybeBool CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => T.CopyStorageFile(storage, oldpath, newpath); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_cos")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetAudioStreamOutputChannelMap(AudioStreamHandle stream, Ref count) => - T.GetAudioStreamOutputChannelMap(stream, count); + public double Cos(double x) => T.Cos(x); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_cosf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetAudioStreamProperties(AudioStreamHandle stream) => - T.GetAudioStreamProperties(stream); + public float Cosf(float x) => T.Cosf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetAudioStreamQueued(AudioStreamHandle stream) => T.GetAudioStreamQueued(stream); + public ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => T.Crc16(crc, data, len); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("Uint16")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetBasePath() => T.GetBasePath(); + public ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) => T.Crc16(crc, data, len); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetBasePathRaw() => T.GetBasePathRaw(); + public uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => T.Crc32(crc, data, len); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => T.GetBooleanProperty(props, name, default_value); + public uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) => T.Crc32(crc, data, len); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) => T.GetBooleanProperty(props, name, default_value); + public AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => T.CreateAudioStream(src_spec, dst_spec); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCameraDriver(int index) => T.GetCameraDriver(index); + public AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) => T.CreateAudioStream(src_spec, dst_spec); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetCameraDriverRaw(int index) => T.GetCameraDriverRaw(index); + public CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => + T.CreateColorCursor(surface, hot_x, hot_y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => - T.GetCameraFormat(camera, spec); + public CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) => + T.CreateColorCursor(surface, hot_x, hot_y); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) => - T.GetCameraFormat(camera, spec); + public ConditionHandle CreateCondition() => T.CreateCondition(); - [return: NativeTypeName("SDL_CameraID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetCameraID(CameraHandle camera) => T.GetCameraID(camera); + public CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] byte* data, + [NativeTypeName("const Uint8 *")] byte* mask, + int w, + int h, + int hot_x, + int hot_y + ) => T.CreateCursor(data, mask, w, h, hot_x, hot_y); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => - T.GetCameraName(instance_id); + public CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] Ref data, + [NativeTypeName("const Uint8 *")] Ref mask, + int w, + int h, + int hot_x, + int hot_y + ) => T.CreateCursor(data, mask, w, h, hot_x, hot_y); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => - T.GetCameraNameRaw(instance_id); + public byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => + T.CreateDirectory(path); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetCameraPermissionState(CameraHandle camera) => - T.GetCameraPermissionState(camera); + public MaybeBool CreateDirectory([NativeTypeName("const char *")] Ref path) => + T.CreateDirectory(path); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CameraPosition GetCameraPosition( - [NativeTypeName("SDL_CameraID")] uint instance_id - ) => T.GetCameraPosition(instance_id); + public EnvironmentHandle CreateEnvironment([NativeTypeName("bool")] byte populated) => + T.CreateEnvironment(populated); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetCameraProperties(CameraHandle camera) => T.GetCameraProperties(camera); + public EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] MaybeBool populated + ) => T.CreateEnvironment(populated); - [return: NativeTypeName("SDL_CameraID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetCameras(int* count) => T.GetCameras(count); + public GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ) => T.CreateGPUBuffer(device, createinfo); - [return: NativeTypeName("SDL_CameraID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCameras(Ref count) => T.GetCameras(count); + public GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ) => T.CreateGPUBuffer(device, createinfo); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CameraSpec** GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - int* count - ) => T.GetCameraSupportedFormats(devid, count); + public GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ) => T.CreateGPUComputePipeline(device, createinfo); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - Ref count - ) => T.GetCameraSupportedFormats(devid, count); + public GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ) => T.CreateGPUComputePipeline(device, createinfo); - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetClipboardData( - [NativeTypeName("const char *")] sbyte* mime_type, - [NativeTypeName("size_t *")] nuint* size - ) => T.GetClipboardData(mime_type, size); + public GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ) => T.CreateGPUDevice(format_flags, debug_mode, name); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetClipboardData( - [NativeTypeName("const char *")] Ref mime_type, - [NativeTypeName("size_t *")] Ref size - ) => T.GetClipboardData(mime_type, size); + public GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ) => T.CreateGPUDevice(format_flags, debug_mode, name); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDeviceWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte** GetClipboardMimeTypes([NativeTypeName("size_t *")] nuint* num_mime_types) => - T.GetClipboardMimeTypes(num_mime_types); + public GPUDeviceHandle CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateGPUDeviceWithProperties(props); - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetClipboardMimeTypes( - [NativeTypeName("size_t *")] Ref num_mime_types - ) => T.GetClipboardMimeTypes(num_mime_types); + public GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ) => T.CreateGPUGraphicsPipeline(device, createinfo); - [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public Ptr GetClipboardText() => T.GetClipboardText(); - - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetClipboardTextRaw() => T.GetClipboardTextRaw(); + public GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ) => T.CreateGPUGraphicsPipeline(device, createinfo); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] byte include_high_density_modes, - DisplayMode* mode - ) => - T.GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - include_high_density_modes, - mode - ); + public GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ) => T.CreateGPUSampler(device, createinfo); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] MaybeBool include_high_density_modes, - Ref mode - ) => - T.GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - include_high_density_modes, - mode - ); + public GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] + Ref createinfo + ) => T.CreateGPUSampler(device, createinfo); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetCPUCacheLineSize() => T.GetCPUCacheLineSize(); + public GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ) => T.CreateGPUShader(device, createinfo); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCurrentAudioDriver() => T.GetCurrentAudioDriver(); + public GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ) => T.CreateGPUShader(device, createinfo); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetCurrentAudioDriverRaw() => T.GetCurrentAudioDriverRaw(); + public GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ) => T.CreateGPUTexture(device, createinfo); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCurrentCameraDriver() => T.GetCurrentCameraDriver(); + public GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] + Ref createinfo + ) => T.CreateGPUTexture(device, createinfo); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetCurrentCameraDriverRaw() => T.GetCurrentCameraDriverRaw(); + public GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ) => T.CreateGPUTransferBuffer(device, createinfo); - [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCurrentDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetCurrentDisplayMode(displayID); + public GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ) => T.CreateGPUTransferBuffer(device, createinfo); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayMode* GetCurrentDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetCurrentDisplayModeRaw(displayID); + public int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => T.CreateHapticEffect(haptic, effect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayOrientation GetCurrentDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetCurrentDisplayOrientation(displayID); + public int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) => T.CreateHapticEffect(haptic, effect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => - T.GetCurrentRenderOutputSize(renderer, w, h); + public MutexHandle CreateMutex() => T.CreateMutex(); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetCurrentRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h - ) => T.GetCurrentRenderOutputSize(renderer, w, h); + public Ptr CreatePalette(int ncolors) => T.CreatePalette(ncolors); - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetCurrentThreadID() => T.GetCurrentThreadID(); + public Palette* CreatePaletteRaw(int ncolors) => T.CreatePaletteRaw(ncolors); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => - T.GetCurrentTime(ticks); + public WindowHandle CreatePopupWindow( + WindowHandle parent, + int offset_x, + int offset_y, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => T.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) => - T.GetCurrentTime(ticks); + public ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ) => T.CreateProcess(args, pipe_stdio); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetCurrentVideoDriver() => T.GetCurrentVideoDriver(); + public ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ) => T.CreateProcess(args, pipe_stdio); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcessWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetCurrentVideoDriverRaw() => T.GetCurrentVideoDriverRaw(); + public ProcessHandle CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateProcessWithProperties(props); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle GetCursor() => T.GetCursor(); + public uint CreateProperties() => T.CreateProperties(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetDateTimeLocalePreferences(DateFormat* dateFormat, TimeFormat* timeFormat) => - T.GetDateTimeLocalePreferences(dateFormat, timeFormat); + public RendererHandle CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] sbyte* name + ) => T.CreateRenderer(window, name); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetDateTimeLocalePreferences( - Ref dateFormat, - Ref timeFormat - ) => T.GetDateTimeLocalePreferences(dateFormat, timeFormat); + public RendererHandle CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] Ref name + ) => T.CreateRenderer(window, name); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetDayOfWeek(int year, int month, int day) => T.GetDayOfWeek(year, month, day); + public RendererHandle CreateRendererWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateRendererWithProperties(props); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetDayOfYear(int year, int month, int day) => T.GetDayOfYear(year, month, day); + public RWLockHandle CreateRWLock() => T.CreateRWLock(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetDaysInMonth(int year, int month) => T.GetDaysInMonth(year, month); + public SemaphoreHandle CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => + T.CreateSemaphore(initial_value); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertionHandler GetDefaultAssertionHandler() => T.GetDefaultAssertionHandler(); + public RendererHandle CreateSoftwareRenderer(Surface* surface) => + T.CreateSoftwareRenderer(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CursorHandle GetDefaultCursor() => T.GetDefaultCursor(); + public RendererHandle CreateSoftwareRenderer(Ref surface) => + T.CreateSoftwareRenderer(surface); - [return: NativeTypeName("SDL_LogOutputFunction")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public LogOutputFunction GetDefaultLogOutputFunction() => T.GetDefaultLogOutputFunction(); + public byte CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => T.CreateStorageDirectory(storage, path); - [return: NativeTypeName("const SDL_DisplayMode *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetDesktopDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetDesktopDisplayMode(displayID); + public MaybeBool CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) => T.CreateStorageDirectory(storage, path); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayMode* GetDesktopDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetDesktopDisplayModeRaw(displayID); + public Ptr CreateSurface(int width, int height, PixelFormat format) => + T.CreateSurface(width, height, format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => T.GetDisplayBounds(displayID, rect); + public Surface* CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + void* pixels, + int pitch + ) => T.CreateSurfaceFrom(width, height, format, pixels, pitch); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) => T.GetDisplayBounds(displayID, rect); + public Ptr CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + Ref pixels, + int pitch + ) => T.CreateSurfaceFrom(width, height, format, pixels, pitch); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => - T.GetDisplayContentScale(displayID); + public Palette* CreateSurfacePalette(Surface* surface) => T.CreateSurfacePalette(surface); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => - T.GetDisplayForPoint(point); + public Ptr CreateSurfacePalette(Ref surface) => + T.CreateSurfacePalette(surface); - [return: NativeTypeName("SDL_DisplayID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) => - T.GetDisplayForPoint(point); + public Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => + T.CreateSurfaceRaw(width, height, format); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => - T.GetDisplayForRect(rect); + public CursorHandle CreateSystemCursor(SystemCursor id) => T.CreateSystemCursor(id); - [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) => - T.GetDisplayForRect(rect); + public Ptr CreateTexture( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => T.CreateTexture(renderer, format, access, w, h); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayForWindow(WindowHandle window) => T.GetDisplayForWindow(window); + public Texture* CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => + T.CreateTextureFromSurface(renderer, surface); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => - T.GetDisplayName(displayID); + public Ptr CreateTextureFromSurface( + RendererHandle renderer, + Ref surface + ) => T.CreateTextureFromSurface(renderer, surface); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => - T.GetDisplayNameRaw(displayID); + public Texture* CreateTextureRaw( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => T.CreateTextureRaw(renderer, format, access, w, h); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => - T.GetDisplayProperties(displayID); + public Ptr CreateTextureWithProperties( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateTextureWithProperties(renderer, props); - [return: NativeTypeName("SDL_DisplayID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetDisplays(int* count) => T.GetDisplays(count); + public Texture* CreateTextureWithPropertiesRaw( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateTextureWithPropertiesRaw(renderer, props); - [return: NativeTypeName("SDL_DisplayID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetDisplays(Ref count) => T.GetDisplays(count); + public ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] sbyte* name, + void* data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => T.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => T.GetDisplayUsableBounds(displayID, rect); + public ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] Ref name, + Ref data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => T.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) => T.GetDisplayUsableBounds(displayID, rect); + public ThreadHandle CreateThreadWithPropertiesRuntime( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => T.CreateThreadWithPropertiesRuntime(props, pfnBeginThread, pfnEndThread); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetError() => T.GetError(); + public WindowHandle CreateWindow( + [NativeTypeName("const char *")] sbyte* title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => T.CreateWindow(title, w, h, flags); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetErrorRaw() => T.GetErrorRaw(); + public WindowHandle CreateWindow( + [NativeTypeName("const char *")] Ref title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => T.CreateWindow(title, w, h, flags); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, - void** userdata - ) => T.GetEventFilter(filter, userdata); + public byte CreateWindowAndRenderer( + [NativeTypeName("const char *")] sbyte* title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + WindowHandle* window, + RendererHandle* renderer + ) => T.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] Ref filter, - Ref2D userdata - ) => T.GetEventFilter(filter, userdata); + public MaybeBool CreateWindowAndRenderer( + [NativeTypeName("const char *")] Ref title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + Ref window, + Ref renderer + ) => T.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float default_value - ) => T.GetFloatProperty(props, name, default_value); + public WindowHandle CreateWindowWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.CreateWindowWithProperties(props); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float default_value - ) => T.GetFloatProperty(props, name, default_value); + public MaybeBool CursorVisible() => T.CursorVisible(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayMode** GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int* count - ) => T.GetFullscreenDisplayModes(displayID, count); + public byte CursorVisibleRaw() => T.CursorVisibleRaw(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref count - ) => T.GetFullscreenDisplayModes(displayID, count); + public byte DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] DateTime* dt, + [NativeTypeName("SDL_Time *")] long* ticks + ) => T.DateTimeToTime(dt, ticks); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadAppleSFSymbolsNameForAxis( - GamepadHandle gamepad, - GamepadAxis axis - ) => T.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); + public MaybeBool DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] Ref dt, + [NativeTypeName("SDL_Time *")] Ref ticks + ) => T.DateTimeToTime(dt, ticks); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( - GamepadHandle gamepad, - GamepadAxis axis - ) => T.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); + public void Delay([NativeTypeName("Uint32")] uint ms) => T.Delay(ms); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadAppleSFSymbolsNameForButton( - GamepadHandle gamepad, - GamepadButton button - ) => T.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); + public void DelayNS([NativeTypeName("Uint64")] ulong ns) => T.DelayNS(ns); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( - GamepadHandle gamepad, - GamepadButton button - ) => T.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); + public void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => T.DelayPrecise(ns); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => - T.GetGamepadAxis(gamepad, axis); + public void DestroyAudioStream(AudioStreamHandle stream) => T.DestroyAudioStream(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadAxis GetGamepadAxisFromString([NativeTypeName("const char *")] sbyte* str) => - T.GetGamepadAxisFromString(str); + public void DestroyCondition(ConditionHandle cond) => T.DestroyCondition(cond); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadAxis GetGamepadAxisFromString( - [NativeTypeName("const char *")] Ref str - ) => T.GetGamepadAxisFromString(str); + public void DestroyCursor(CursorHandle cursor) => T.DestroyCursor(cursor); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => - T.GetGamepadBindings(gamepad, count); + public void DestroyEnvironment(EnvironmentHandle env) => T.DestroyEnvironment(env); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetGamepadBindings(GamepadHandle gamepad, Ref count) => - T.GetGamepadBindings(gamepad, count); + public void DestroyGPUDevice(GPUDeviceHandle device) => T.DestroyGPUDevice(device); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => - T.GetGamepadButton(gamepad, button); + public void DestroyHapticEffect(HapticHandle haptic, int effect) => + T.DestroyHapticEffect(haptic, effect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] sbyte* str - ) => T.GetGamepadButtonFromString(str); + public void DestroyMutex(MutexHandle mutex) => T.DestroyMutex(mutex); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void DestroyPalette(Palette* palette) => T.DestroyPalette(palette); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] Ref str - ) => T.GetGamepadButtonFromString(str); + public void DestroyPalette(Ref palette) => T.DestroyPalette(palette); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadButtonLabel GetGamepadButtonLabel( - GamepadHandle gamepad, - GamepadButton button - ) => T.GetGamepadButtonLabel(gamepad, button); + public void DestroyProcess(ProcessHandle process) => T.DestroyProcess(process); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadButtonLabel GetGamepadButtonLabelForType( - GamepadType type, - GamepadButton button - ) => T.GetGamepadButtonLabelForType(type, button); + public void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + T.DestroyProperties(props); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => - T.GetGamepadButtonRaw(gamepad, button); + public void DestroyRenderer(RendererHandle renderer) => T.DestroyRenderer(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => - T.GetGamepadConnectionState(gamepad); + public void DestroyRWLock(RWLockHandle rwlock) => T.DestroyRWLock(rwlock); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => - T.GetGamepadFirmwareVersion(gamepad); + public void DestroySemaphore(SemaphoreHandle sem) => T.DestroySemaphore(sem); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadHandle GetGamepadFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadFromID(instance_id); + public void DestroySurface(Surface* surface) => T.DestroySurface(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadHandle GetGamepadFromPlayerIndex(int player_index) => - T.GetGamepadFromPlayerIndex(player_index); + public void DestroySurface(Ref surface) => T.DestroySurface(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Guid GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetGamepadGuidForID(instance_id); + public void DestroyTexture(Texture* texture) => T.DestroyTexture(texture); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetGamepadID(GamepadHandle gamepad) => T.GetGamepadID(gamepad); + public void DestroyTexture(Ref texture) => T.DestroyTexture(texture); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => - T.GetGamepadJoystick(gamepad); + public void DestroyWindow(WindowHandle window) => T.DestroyWindow(window); - [return: NativeTypeName("char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadMapping(GamepadHandle gamepad) => T.GetGamepadMapping(gamepad); + public MaybeBool DestroyWindowSurface(WindowHandle window) => + T.DestroyWindowSurface(window); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadMappingForGuid(Guid guid) => T.GetGamepadMappingForGuid(guid); + public byte DestroyWindowSurfaceRaw(WindowHandle window) => + T.DestroyWindowSurfaceRaw(window); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadMappingForGuidRaw(Guid guid) => T.GetGamepadMappingForGuidRaw(guid); + public void DetachThread(ThreadHandle thread) => T.DetachThread(thread); - [return: NativeTypeName("char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadMappingForID( + public MaybeBool DetachVirtualJoystick( [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadMappingForID(instance_id); + ) => T.DetachVirtualJoystick(instance_id); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadMappingForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadMappingForIDRaw(instance_id); + public byte DetachVirtualJoystickRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.DetachVirtualJoystickRaw(instance_id); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => - T.GetGamepadMappingRaw(gamepad); + public MaybeBool DisableScreenSaver() => T.DisableScreenSaver(); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte** GetGamepadMappings(int* count) => T.GetGamepadMappings(count); + public byte DisableScreenSaverRaw() => T.DisableScreenSaverRaw(); - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUCompute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetGamepadMappings(Ref count) => T.GetGamepadMappings(count); + public void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ) => T.DispatchGPUCompute(compute_pass, groupcount_x, groupcount_y, groupcount_z); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUComputeIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadName(GamepadHandle gamepad) => T.GetGamepadName(gamepad); + public void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ) => T.DispatchGPUComputeIndirect(compute_pass, buffer, offset); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadNameForID(instance_id); + public void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ) => T.DownloadFromGPUBuffer(copy_pass, source, destination); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetGamepadNameForIDRaw(instance_id); + public void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination + ) => T.DownloadFromGPUBuffer(copy_pass, source, destination); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => T.GetGamepadNameRaw(gamepad); + public void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + GPUTextureTransferInfo* destination + ) => T.DownloadFromGPUTexture(copy_pass, source, destination); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadPath(GamepadHandle gamepad) => T.GetGamepadPath(gamepad); + public void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination + ) => T.DownloadFromGPUTexture(copy_pass, source, destination); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitives")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadPathForID(instance_id); + public void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ) => + T.DrawGPUIndexedPrimitives( + render_pass, + num_indices, + num_instances, + first_index, + vertex_offset, + first_instance + ); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetGamepadPathForIDRaw(instance_id); + public void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => T.DrawGPUIndexedPrimitivesIndirect(render_pass, buffer, offset, draw_count); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitives")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => T.GetGamepadPathRaw(gamepad); + public void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ) => + T.DrawGPUPrimitives( + render_pass, + num_vertices, + num_instances, + first_vertex, + first_instance + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetGamepadPlayerIndex(GamepadHandle gamepad) => T.GetGamepadPlayerIndex(gamepad); + public void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => T.DrawGPUPrimitivesIndirect(render_pass, buffer, offset, draw_count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetGamepadPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadPlayerIndexForID(instance_id); + public Surface* DuplicateSurface(Surface* surface) => T.DuplicateSurface(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => - T.GetGamepadPowerInfo(gamepad, percent); + public Ptr DuplicateSurface(Ref surface) => T.DuplicateSurface(surface); + [return: NativeTypeName("SDL_EGLConfig")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) => - T.GetGamepadPowerInfo(gamepad, percent); + public Ptr EGLGetCurrentConfig() => T.EGLGetCurrentConfig(); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] + [return: NativeTypeName("SDL_EGLConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadProduct(GamepadHandle gamepad) => T.GetGamepadProduct(gamepad); + public void* EGLGetCurrentConfigRaw() => T.EGLGetCurrentConfigRaw(); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] + [return: NativeTypeName("SDL_EGLDisplay")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetGamepadProductForID(instance_id); + public Ptr EGLGetCurrentDisplay() => T.EGLGetCurrentDisplay(); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] + [return: NativeTypeName("SDL_EGLDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadProductVersion(GamepadHandle gamepad) => - T.GetGamepadProductVersion(gamepad); + public void* EGLGetCurrentDisplayRaw() => T.EGLGetCurrentDisplayRaw(); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadProductVersionForID(instance_id); + public FunctionPointer EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + T.EGLGetProcAddress(proc); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] + [return: NativeTypeName("SDL_FunctionPointer")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetGamepadProperties(GamepadHandle gamepad) => T.GetGamepadProperties(gamepad); + public FunctionPointer EGLGetProcAddress( + [NativeTypeName("const char *")] Ref proc + ) => T.EGLGetProcAddress(proc); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [return: NativeTypeName("SDL_EGLSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetGamepads(int* count) => T.GetGamepads(count); + public Ptr EGLGetWindowSurface(WindowHandle window) => T.EGLGetWindowSurface(window); - [return: NativeTypeName("SDL_JoystickID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [return: NativeTypeName("SDL_EGLSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepads(Ref count) => T.GetGamepads(count); + public void* EGLGetWindowSurfaceRaw(WindowHandle window) => + T.EGLGetWindowSurfaceRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - float* data, - int num_values - ) => T.GetGamepadSensorData(gamepad, type, data, num_values); + public void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, + void* userdata + ) => + T.EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + userdata + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - Ref data, - int num_values - ) => T.GetGamepadSensorData(gamepad, type, data, num_values); + public void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, + Ref userdata + ) => + T.EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + userdata + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => - T.GetGamepadSensorDataRate(gamepad, type); + public MaybeBool EnableScreenSaver() => T.EnableScreenSaver(); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadSerial(GamepadHandle gamepad) => T.GetGamepadSerial(gamepad); + public byte EnableScreenSaverRaw() => T.EnableScreenSaverRaw(); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUComputePass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => T.GetGamepadSerialRaw(gamepad); + public void EndGPUComputePass(GPUComputePassHandle compute_pass) => + T.EndGPUComputePass(compute_pass); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUCopyPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetGamepadSteamHandle(GamepadHandle gamepad) => - T.GetGamepadSteamHandle(gamepad); + public void EndGPUCopyPass(GPUCopyPassHandle copy_pass) => T.EndGPUCopyPass(copy_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPURenderPass")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void EndGPURenderPass(GPURenderPassHandle render_pass) => + T.EndGPURenderPass(render_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => T.EnterAppMainCallbacks(argc, argv, appinit, appiter, appevent, appquit); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadStringForAxis(GamepadAxis axis) => - T.GetGamepadStringForAxis(axis); + public int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => T.EnterAppMainCallbacks(argc, argv, appinit, appiter, appevent, appquit); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => - T.GetGamepadStringForAxisRaw(axis); + public byte EnumerateDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata + ) => T.EnumerateDirectory(path, callback, userdata); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadStringForButton(GamepadButton button) => - T.GetGamepadStringForButton(button); + public MaybeBool EnumerateDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata + ) => T.EnumerateDirectory(path, callback, userdata); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => - T.GetGamepadStringForButtonRaw(button); + public byte EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] + EnumeratePropertiesCallback callback, + void* userdata + ) => T.EnumerateProperties(props, callback, userdata); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetGamepadStringForType(GamepadType type) => - T.GetGamepadStringForType(type); + public MaybeBool EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] + EnumeratePropertiesCallback callback, + Ref userdata + ) => T.EnumerateProperties(props, callback, userdata); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetGamepadStringForTypeRaw(GamepadType type) => - T.GetGamepadStringForTypeRaw(type); + public byte EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata + ) => T.EnumerateStorageDirectory(storage, path, callback, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - bool* down, - float* x, - float* y, - float* pressure - ) => T.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); + public MaybeBool EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata + ) => T.EnumerateStorageDirectory(storage, path, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - Ref down, - Ref x, - Ref y, - Ref pressure - ) => T.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); + public MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => + T.EventEnabled(type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetGamepadType(GamepadHandle gamepad) => T.GetGamepadType(gamepad); + public byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => + T.EventEnabledRaw(type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_exp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetGamepadTypeForID(instance_id); + public double Exp(double x) => T.Exp(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_expf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetGamepadTypeFromString([NativeTypeName("const char *")] sbyte* str) => - T.GetGamepadTypeFromString(str); + public float Expf(float x) => T.Expf(x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_fabs")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetGamepadTypeFromString( - [NativeTypeName("const char *")] Ref str - ) => T.GetGamepadTypeFromString(str); + public double Fabs(double x) => T.Fabs(x); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadVendor(GamepadHandle gamepad) => T.GetGamepadVendor(gamepad); + public byte FillSurfaceRect( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("Uint32")] uint color + ) => T.FillSurfaceRect(dst, rect, color); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetGamepadVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetGamepadVendorForID(instance_id); + public MaybeBool FillSurfaceRect( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("Uint32")] uint color + ) => T.FillSurfaceRect(dst, rect, color); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetGlobalMouseState(float* x, float* y) => T.GetGlobalMouseState(x, y); + public byte FillSurfaceRects( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int count, + [NativeTypeName("Uint32")] uint color + ) => T.FillSurfaceRects(dst, rects, count, color); - [return: NativeTypeName("SDL_MouseButtonFlags")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetGlobalMouseState(Ref x, Ref y) => T.GetGlobalMouseState(x, y); + public MaybeBool FillSurfaceRects( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rects, + int count, + [NativeTypeName("Uint32")] uint color + ) => T.FillSurfaceRects(dst, rects, count, color); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetGlobalProperties() => T.GetGlobalProperties(); + public void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => T.FilterEvents(filter, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetGrabbedWindow() => T.GetGrabbedWindow(); + public void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => T.FilterEvents(filter, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => - T.GetHapticEffectStatus(haptic, effect); + public MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => + T.FlashWindow(window, operation); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => - T.GetHapticEffectStatusRaw(haptic, effect); + public byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => + T.FlashWindowRaw(window, operation); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetHapticFeatures(HapticHandle haptic) => T.GetHapticFeatures(haptic); + public byte FlipSurface(Surface* surface, FlipMode flip) => T.FlipSurface(surface, flip); - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HapticHandle GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => - T.GetHapticFromID(instance_id); + public MaybeBool FlipSurface(Ref surface, FlipMode flip) => + T.FlipSurface(surface, flip); - [return: NativeTypeName("SDL_HapticID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] + [NativeFunction("SDL3", EntryPoint = "SDL_floor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetHapticID(HapticHandle haptic) => T.GetHapticID(haptic); + public double Floor(double x) => T.Floor(x); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [NativeFunction("SDL3", EntryPoint = "SDL_floorf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetHapticName(HapticHandle haptic) => T.GetHapticName(haptic); + public float Floorf(float x) => T.Floorf(x); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetHapticNameForID([NativeTypeName("SDL_HapticID")] uint instance_id) => - T.GetHapticNameForID(instance_id); + public MaybeBool FlushAudioStream(AudioStreamHandle stream) => + T.FlushAudioStream(stream); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => - T.GetHapticNameForIDRaw(instance_id); + public byte FlushAudioStreamRaw(AudioStreamHandle stream) => T.FlushAudioStreamRaw(stream); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetHapticNameRaw(HapticHandle haptic) => T.GetHapticNameRaw(haptic); + public void FlushEvent([NativeTypeName("Uint32")] uint type) => T.FlushEvent(type); - [return: NativeTypeName("SDL_HapticID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetHaptics(int* count) => T.GetHaptics(count); + public void FlushEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => T.FlushEvents(minType, maxType); - [return: NativeTypeName("SDL_HapticID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetHaptics(Ref count) => T.GetHaptics(count); + public MaybeBool FlushIO(IOStreamHandle context) => T.FlushIO(context); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => T.GetHint(name); + public byte FlushIORaw(IOStreamHandle context) => T.FlushIORaw(context); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetHint([NativeTypeName("const char *")] Ref name) => - T.GetHint(name); + public MaybeBool FlushRenderer(RendererHandle renderer) => T.FlushRenderer(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetHintBoolean( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => T.GetHintBoolean(name, default_value); + public byte FlushRendererRaw(RendererHandle renderer) => T.FlushRendererRaw(renderer); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [NativeFunction("SDL3", EntryPoint = "SDL_fmod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetHintBoolean( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) => T.GetHintBoolean(name, default_value); + public double Fmod(double x, double y) => T.Fmod(x, y); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_fmodf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetIOProperties(IOStreamHandle context) => T.GetIOProperties(context); + public float Fmodf(float x, float y) => T.Fmodf(x, y); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long GetIOSize(IOStreamHandle context) => T.GetIOSize(context); + public void Free(void* mem) => T.Free(mem); - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStatus GetIOStatus(IOStreamHandle context) => T.GetIOStatus(context); + public void Free(Ref mem) => T.Free(mem); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public short GetJoystickAxis(JoystickHandle joystick, int axis) => - T.GetJoystickAxis(joystick, axis); + public MaybeBool GamepadConnected(GamepadHandle gamepad) => + T.GamepadConnected(gamepad); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] short* state - ) => T.GetJoystickAxisInitialState(joystick, axis, state); + public byte GamepadConnectedRaw(GamepadHandle gamepad) => T.GamepadConnectedRaw(gamepad); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] Ref state - ) => T.GetJoystickAxisInitialState(joystick, axis, state); + public MaybeBool GamepadEventsEnabled() => T.GamepadEventsEnabled(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => - T.GetJoystickBall(joystick, ball, dx, dy); + public byte GamepadEventsEnabledRaw() => T.GamepadEventsEnabledRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetJoystickBall( - JoystickHandle joystick, - int ball, - Ref dx, - Ref dy - ) => T.GetJoystickBall(joystick, ball, dx, dy); + public MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => + T.GamepadHasAxis(gamepad, axis); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => - T.GetJoystickButton(joystick, button); + public byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => + T.GamepadHasAxisRaw(gamepad, axis); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => - T.GetJoystickButtonRaw(joystick, button); + public MaybeBool GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => + T.GamepadHasButton(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => - T.GetJoystickConnectionState(joystick); + public byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => + T.GamepadHasButtonRaw(gamepad, button); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => - T.GetJoystickFirmwareVersion(joystick); + public MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => + T.GamepadHasSensor(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickHandle GetJoystickFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickFromID(instance_id); + public byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => + T.GamepadHasSensorRaw(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickHandle GetJoystickFromPlayerIndex(int player_index) => - T.GetJoystickFromPlayerIndex(player_index); + public MaybeBool GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => + T.GamepadSensorEnabled(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Guid GetJoystickGuid(JoystickHandle joystick) => T.GetJoystickGuid(joystick); + public byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => + T.GamepadSensorEnabledRaw(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Guid GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetJoystickGuidForID(instance_id); + public void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ) => T.GenerateMipmapsForGPUTexture(command_buffer, texture); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] ushort* vendor, - [NativeTypeName("Uint16 *")] ushort* product, - [NativeTypeName("Uint16 *")] ushort* version, - [NativeTypeName("Uint16 *")] ushort* crc16 - ) => T.GetJoystickGuidInfo(guid, vendor, product, version, crc16); + public sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => + T.GetAppMetadataProperty(name); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] Ref vendor, - [NativeTypeName("Uint16 *")] Ref product, - [NativeTypeName("Uint16 *")] Ref version, - [NativeTypeName("Uint16 *")] Ref crc16 - ) => T.GetJoystickGuidInfo(guid, vendor, product, version, crc16); + public Ptr GetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name + ) => T.GetAppMetadataProperty(name); - [return: NativeTypeName("Uint8")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetJoystickHat(JoystickHandle joystick, int hat) => - T.GetJoystickHat(joystick, hat); + public AssertionHandler GetAssertionHandler(void** puserdata) => + T.GetAssertionHandler(puserdata); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] + [return: NativeTypeName("SDL_AssertionHandler")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetJoystickID(JoystickHandle joystick) => T.GetJoystickID(joystick); + public AssertionHandler GetAssertionHandler(Ref2D puserdata) => + T.GetAssertionHandler(puserdata); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("const SDL_AssertData *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoystickName(JoystickHandle joystick) => T.GetJoystickName(joystick); + public Ptr GetAssertionReport() => T.GetAssertionReport(); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] + [return: NativeTypeName("const SDL_AssertData *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoystickNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickNameForID(instance_id); + public AssertData* GetAssertionReportRaw() => T.GetAssertionReportRaw(); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetJoystickNameForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickNameForIDRaw(instance_id); + public int GetAtomicInt(AtomicInt* a) => T.GetAtomicInt(a); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetJoystickNameRaw(JoystickHandle joystick) => T.GetJoystickNameRaw(joystick); + public int GetAtomicInt(Ref a) => T.GetAtomicInt(a); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoystickPath(JoystickHandle joystick) => T.GetJoystickPath(joystick); + public void* GetAtomicPointer(void** a) => T.GetAtomicPointer(a); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoystickPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickPathForID(instance_id); + public Ptr GetAtomicPointer(Ref2D a) => T.GetAtomicPointer(a); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetJoystickPathForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickPathForIDRaw(instance_id); + public uint GetAtomicU32(AtomicU32* a) => T.GetAtomicU32(a); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetJoystickPathRaw(JoystickHandle joystick) => T.GetJoystickPathRaw(joystick); + public uint GetAtomicU32(Ref a) => T.GetAtomicU32(a); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetJoystickPlayerIndex(JoystickHandle joystick) => - T.GetJoystickPlayerIndex(joystick); + public int* GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + int* count + ) => T.GetAudioDeviceChannelMap(devid, count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetJoystickPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickPlayerIndexForID(instance_id); + public Ptr GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref count + ) => T.GetAudioDeviceChannelMap(devid, count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => - T.GetJoystickPowerInfo(joystick, percent); + public byte GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioSpec* spec, + int* sample_frames + ) => T.GetAudioDeviceFormat(devid, spec, sample_frames); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) => - T.GetJoystickPowerInfo(joystick, percent); - - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickProduct(JoystickHandle joystick) => T.GetJoystickProduct(joystick); + public MaybeBool GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref spec, + Ref sample_frames + ) => T.GetAudioDeviceFormat(devid, spec, sample_frames); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickProductForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickProductForID(instance_id); + public float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + T.GetAudioDeviceGain(devid); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickProductVersion(JoystickHandle joystick) => - T.GetJoystickProductVersion(joystick); + public Ptr GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + T.GetAudioDeviceName(devid); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickProductVersionForID(instance_id); + public sbyte* GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + T.GetAudioDeviceNameRaw(devid); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetJoystickProperties(JoystickHandle joystick) => - T.GetJoystickProperties(joystick); + public Ptr GetAudioDriver(int index) => T.GetAudioDriver(index); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetJoysticks(int* count) => T.GetJoysticks(count); + public sbyte* GetAudioDriverRaw(int index) => T.GetAudioDriverRaw(index); - [return: NativeTypeName("SDL_JoystickID *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoysticks(Ref count) => T.GetJoysticks(count); + public Ptr GetAudioFormatName(AudioFormat format) => T.GetAudioFormatName(format); [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetJoystickSerial(JoystickHandle joystick) => - T.GetJoystickSerial(joystick); + public sbyte* GetAudioFormatNameRaw(AudioFormat format) => T.GetAudioFormatNameRaw(format); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => - T.GetJoystickSerialRaw(joystick); + public uint* GetAudioPlaybackDevices(int* count) => T.GetAudioPlaybackDevices(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickType GetJoystickType(JoystickHandle joystick) => T.GetJoystickType(joystick); + public Ptr GetAudioPlaybackDevices(Ref count) => + T.GetAudioPlaybackDevices(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickType GetJoystickTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetJoystickTypeForID(instance_id); + public uint* GetAudioRecordingDevices(int* count) => T.GetAudioRecordingDevices(count); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickVendor(JoystickHandle joystick) => T.GetJoystickVendor(joystick); + public Ptr GetAudioRecordingDevices(Ref count) => + T.GetAudioRecordingDevices(count); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetJoystickVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.GetJoystickVendorForID(instance_id); + public int GetAudioStreamAvailable(AudioStreamHandle stream) => + T.GetAudioStreamAvailable(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetKeyboardFocus() => T.GetKeyboardFocus(); + public int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => + T.GetAudioStreamData(stream, buf, len); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetKeyboardNameForID( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => T.GetKeyboardNameForID(instance_id); + public int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) => + T.GetAudioStreamData(stream, buf, len); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetKeyboardNameForIDRaw( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => T.GetKeyboardNameForIDRaw(instance_id); + public uint GetAudioStreamDevice(AudioStreamHandle stream) => + T.GetAudioStreamDevice(stream); - [return: NativeTypeName("SDL_KeyboardID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetKeyboards(int* count) => T.GetKeyboards(count); + public byte GetAudioStreamFormat( + AudioStreamHandle stream, + AudioSpec* src_spec, + AudioSpec* dst_spec + ) => T.GetAudioStreamFormat(stream, src_spec, dst_spec); - [return: NativeTypeName("SDL_KeyboardID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetKeyboards(Ref count) => T.GetKeyboards(count); + public MaybeBool GetAudioStreamFormat( + AudioStreamHandle stream, + Ref src_spec, + Ref dst_spec + ) => T.GetAudioStreamFormat(stream, src_spec, dst_spec); - [return: NativeTypeName("const bool *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public bool* GetKeyboardState(int* numkeys) => T.GetKeyboardState(numkeys); + public float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => + T.GetAudioStreamFrequencyRatio(stream); - [return: NativeTypeName("const bool *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetKeyboardState(Ref numkeys) => T.GetKeyboardState(numkeys); + public float GetAudioStreamGain(AudioStreamHandle stream) => T.GetAudioStreamGain(stream); - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => - T.GetKeyFromName(name); + public int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => + T.GetAudioStreamInputChannelMap(stream, count); - [return: NativeTypeName("SDL_Keycode")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public uint GetKeyFromName([NativeTypeName("const char *")] Ref name) => - T.GetKeyFromName(name); - - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] byte key_event - ) => T.GetKeyFromScancode(scancode, modstate, key_event); + public Ptr GetAudioStreamInputChannelMap(AudioStreamHandle stream, Ref count) => + T.GetAudioStreamInputChannelMap(stream, count); - [return: NativeTypeName("SDL_Keycode")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] MaybeBool key_event - ) => T.GetKeyFromScancode(scancode, modstate, key_event); + public int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => + T.GetAudioStreamOutputChannelMap(stream, count); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => T.GetKeyName(key); + public Ptr GetAudioStreamOutputChannelMap(AudioStreamHandle stream, Ref count) => + T.GetAudioStreamOutputChannelMap(stream, count); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => - T.GetKeyNameRaw(key); + public uint GetAudioStreamProperties(AudioStreamHandle stream) => + T.GetAudioStreamProperties(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, - void** userdata - ) => T.GetLogOutputFunction(callback, userdata); + public int GetAudioStreamQueued(AudioStreamHandle stream) => T.GetAudioStreamQueued(stream); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, - Ref2D userdata - ) => T.GetLogOutputFunction(callback, userdata); + public Ptr GetBasePath() => T.GetBasePath(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public LogPriority GetLogPriority(int category) => T.GetLogPriority(category); + public sbyte* GetBasePathRaw() => T.GetBasePathRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetMasksForPixelFormat( - PixelFormat format, - int* bpp, - [NativeTypeName("Uint32 *")] uint* Rmask, - [NativeTypeName("Uint32 *")] uint* Gmask, - [NativeTypeName("Uint32 *")] uint* Bmask, - [NativeTypeName("Uint32 *")] uint* Amask - ) => T.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); + public byte GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value + ) => T.GetBooleanProperty(props, name, default_value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetMasksForPixelFormat( - PixelFormat format, - Ref bpp, - [NativeTypeName("Uint32 *")] Ref Rmask, - [NativeTypeName("Uint32 *")] Ref Gmask, - [NativeTypeName("Uint32 *")] Ref Bmask, - [NativeTypeName("Uint32 *")] Ref Amask - ) => T.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); + public MaybeBool GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value + ) => T.GetBooleanProperty(props, name, default_value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetMaxHapticEffects(HapticHandle haptic) => T.GetMaxHapticEffects(haptic); + public Ptr GetCameraDriver(int index) => T.GetCameraDriver(index); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetMaxHapticEffectsPlaying(HapticHandle haptic) => - T.GetMaxHapticEffectsPlaying(haptic); + public sbyte* GetCameraDriverRaw(int index) => T.GetCameraDriverRaw(index); - [return: NativeTypeName("SDL_MouseID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetMice(int* count) => T.GetMice(count); + public byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => + T.GetCameraFormat(camera, spec); - [return: NativeTypeName("SDL_MouseID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetMice(Ref count) => T.GetMice(count); + public MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) => + T.GetCameraFormat(camera, spec); - [return: NativeTypeName("SDL_Keymod")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] + [return: NativeTypeName("SDL_CameraID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ushort GetModState() => T.GetModState(); + public uint GetCameraID(CameraHandle camera) => T.GetCameraID(camera); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetMouseFocus() => T.GetMouseFocus(); + public Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => + T.GetCameraName(instance_id); [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => - T.GetMouseNameForID(instance_id); + public sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => + T.GetCameraNameRaw(instance_id); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => - T.GetMouseNameForIDRaw(instance_id); + public int GetCameraPermissionState(CameraHandle camera) => + T.GetCameraPermissionState(camera); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetMouseState(float* x, float* y) => T.GetMouseState(x, y); + public CameraPosition GetCameraPosition( + [NativeTypeName("SDL_CameraID")] uint instance_id + ) => T.GetCameraPosition(instance_id); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetMouseState(Ref x, Ref y) => T.GetMouseState(x, y); + public uint GetCameraProperties(CameraHandle camera) => T.GetCameraProperties(camera); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] + [return: NativeTypeName("SDL_CameraID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayOrientation GetNaturalDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => T.GetNaturalDisplayOrientation(displayID); + public uint* GetCameras(int* count) => T.GetCameras(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] + [return: NativeTypeName("SDL_CameraID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumAudioDrivers() => T.GetNumAudioDrivers(); + public Ptr GetCameras(Ref count) => T.GetCameras(count); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long default_value - ) => T.GetNumberProperty(props, name, default_value); + public CameraSpec** GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + int* count + ) => T.GetCameraSupportedFormats(devid, count); - [return: NativeTypeName("Sint64")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long default_value - ) => T.GetNumberProperty(props, name, default_value); + public Ptr2D GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + Ref count + ) => T.GetCameraSupportedFormats(devid, count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumCameraDrivers() => T.GetNumCameraDrivers(); + public void* GetClipboardData( + [NativeTypeName("const char *")] sbyte* mime_type, + [NativeTypeName("size_t *")] nuint* size + ) => T.GetClipboardData(mime_type, size); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => - T.GetNumGamepadTouchpadFingers(gamepad, touchpad); + public Ptr GetClipboardData( + [NativeTypeName("const char *")] Ref mime_type, + [NativeTypeName("size_t *")] Ref size + ) => T.GetClipboardData(mime_type, size); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumGamepadTouchpads(GamepadHandle gamepad) => - T.GetNumGamepadTouchpads(gamepad); + public sbyte** GetClipboardMimeTypes([NativeTypeName("size_t *")] nuint* num_mime_types) => + T.GetClipboardMimeTypes(num_mime_types); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumHapticAxes(HapticHandle haptic) => T.GetNumHapticAxes(haptic); + public Ptr2D GetClipboardMimeTypes( + [NativeTypeName("size_t *")] Ref num_mime_types + ) => T.GetClipboardMimeTypes(num_mime_types); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumJoystickAxes(JoystickHandle joystick) => T.GetNumJoystickAxes(joystick); + public Ptr GetClipboardText() => T.GetClipboardText(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumJoystickBalls(JoystickHandle joystick) => T.GetNumJoystickBalls(joystick); + public sbyte* GetClipboardTextRaw() => T.GetClipboardTextRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumJoystickButtons(JoystickHandle joystick) => - T.GetNumJoystickButtons(joystick); + public byte GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] byte include_high_density_modes, + DisplayMode* mode + ) => + T.GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + include_high_density_modes, + mode + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumJoystickHats(JoystickHandle joystick) => T.GetNumJoystickHats(joystick); + public MaybeBool GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] MaybeBool include_high_density_modes, + Ref mode + ) => + T.GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + include_high_density_modes, + mode + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumLogicalCPUCores() => T.GetNumLogicalCPUCores(); + public int GetCPUCacheLineSize() => T.GetCPUCacheLineSize(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumRenderDrivers() => T.GetNumRenderDrivers(); + public Ptr GetCurrentAudioDriver() => T.GetCurrentAudioDriver(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetNumVideoDrivers() => T.GetNumVideoDrivers(); + public sbyte* GetCurrentAudioDriverRaw() => T.GetCurrentAudioDriverRaw(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => - T.GetPathInfo(path, info); + public Ptr GetCurrentCameraDriver() => T.GetCurrentCameraDriver(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetPathInfo( - [NativeTypeName("const char *")] Ref path, - Ref info - ) => T.GetPathInfo(path, info); + public sbyte* GetCurrentCameraDriverRaw() => T.GetCurrentCameraDriverRaw(); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetPerformanceCounter() => T.GetPerformanceCounter(); + public Ptr GetCurrentDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetCurrentDisplayMode(displayID); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetPerformanceFrequency() => T.GetPerformanceFrequency(); + public DisplayMode* GetCurrentDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetCurrentDisplayModeRaw(displayID); - [return: NativeTypeName("const SDL_PixelFormatDetails *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPixelFormatDetails(PixelFormat format) => - T.GetPixelFormatDetails(format); + public DisplayOrientation GetCurrentDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetCurrentDisplayOrientation(displayID); - [return: NativeTypeName("const SDL_PixelFormatDetails *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => - T.GetPixelFormatDetailsRaw(format); + public byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => + T.GetCurrentRenderOutputSize(renderer, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PixelFormat GetPixelFormatForMasks( - int bpp, - [NativeTypeName("Uint32")] uint Rmask, - [NativeTypeName("Uint32")] uint Gmask, - [NativeTypeName("Uint32")] uint Bmask, - [NativeTypeName("Uint32")] uint Amask - ) => T.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); + public MaybeBool GetCurrentRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h + ) => T.GetCurrentRenderOutputSize(renderer, w, h); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPixelFormatName(PixelFormat format) => T.GetPixelFormatName(format); + public ulong GetCurrentThreadID() => T.GetCurrentThreadID(); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetPixelFormatNameRaw(PixelFormat format) => T.GetPixelFormatNameRaw(format); + public byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => + T.GetCurrentTime(ticks); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPlatform() => T.GetPlatform(); + public MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) => + T.GetCurrentTime(ticks); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetPlatformRaw() => T.GetPlatformRaw(); + public Ptr GetCurrentVideoDriver() => T.GetCurrentVideoDriver(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* default_value - ) => T.GetPointerProperty(props, name, default_value); + public sbyte* GetCurrentVideoDriverRaw() => T.GetCurrentVideoDriverRaw(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref default_value - ) => T.GetPointerProperty(props, name, default_value); + public CursorHandle GetCursor() => T.GetCursor(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PowerState GetPowerInfo(int* seconds, int* percent) => - T.GetPowerInfo(seconds, percent); + public byte GetDateTimeLocalePreferences(DateFormat* dateFormat, TimeFormat* timeFormat) => + T.GetDateTimeLocalePreferences(dateFormat, timeFormat); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PowerState GetPowerInfo(Ref seconds, Ref percent) => - T.GetPowerInfo(seconds, percent); + public MaybeBool GetDateTimeLocalePreferences( + Ref dateFormat, + Ref timeFormat + ) => T.GetDateTimeLocalePreferences(dateFormat, timeFormat); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Locale** GetPreferredLocales(int* count) => T.GetPreferredLocales(count); + public int GetDayOfWeek(int year, int month, int day) => T.GetDayOfWeek(year, month, day); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetPreferredLocales(Ref count) => T.GetPreferredLocales(count); + public int GetDayOfYear(int year, int month, int day) => T.GetDayOfYear(year, month, day); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetPrefPath( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app - ) => T.GetPrefPath(org, app); + public int GetDaysInMonth(int year, int month) => T.GetDaysInMonth(year, month); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPrefPath( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app - ) => T.GetPrefPath(org, app); + public AssertionHandler GetDefaultAssertionHandler() => T.GetDefaultAssertionHandler(); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetPrimaryDisplay() => T.GetPrimaryDisplay(); + public CursorHandle GetDefaultCursor() => T.GetDefaultCursor(); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] + [return: NativeTypeName("SDL_LogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetPrimarySelectionText() => T.GetPrimarySelectionText(); + public LogOutputFunction GetDefaultLogOutputFunction() => T.GetDefaultLogOutputFunction(); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetPrimarySelectionTextRaw() => T.GetPrimarySelectionTextRaw(); + public Ptr GetDesktopDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetDesktopDisplayMode(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => T.GetPropertyType(props, name); + public DisplayMode* GetDesktopDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetDesktopDisplayModeRaw(displayID); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) => T.GetPropertyType(props, name); + public byte GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => T.GetDisplayBounds(displayID, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetRealGamepadType(GamepadHandle gamepad) => - T.GetRealGamepadType(gamepad); + public MaybeBool GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) => T.GetDisplayBounds(displayID, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadType GetRealGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.GetRealGamepadTypeForID(instance_id); + public float GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => + T.GetDisplayContentScale(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int* X1, - int* Y1, - int* X2, - int* Y2 - ) => T.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); + public uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => + T.GetDisplayForPoint(point); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) => T.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); + public uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) => + T.GetDisplayForPoint(point); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* rect, - float* X1, - float* Y1, - float* X2, - float* Y2 - ) => T.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); + public uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => + T.GetDisplayForRect(rect); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) => T.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); + public uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) => + T.GetDisplayForRect(rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Point* points, - int count, - [NativeTypeName("const SDL_Rect *")] Rect* clip, - Rect* result - ) => T.GetRectEnclosingPoints(points, count, clip, result); + public uint GetDisplayForWindow(WindowHandle window) => T.GetDisplayForWindow(window); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Ref points, - int count, - [NativeTypeName("const SDL_Rect *")] Ref clip, - Ref result - ) => T.GetRectEnclosingPoints(points, count, clip, result); + public Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => + T.GetDisplayName(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count, - [NativeTypeName("const SDL_FRect *")] FRect* clip, - FRect* result - ) => T.GetRectEnclosingPointsFloat(points, count, clip, result); + public sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => + T.GetDisplayNameRaw(displayID); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count, - [NativeTypeName("const SDL_FRect *")] Ref clip, - Ref result - ) => T.GetRectEnclosingPointsFloat(points, count, clip, result); + public uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => + T.GetDisplayProperties(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] + [return: NativeTypeName("SDL_DisplayID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => T.GetRectIntersection(A, B, result); + public uint* GetDisplays(int* count) => T.GetDisplays(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) => T.GetRectIntersection(A, B, result); + public Ptr GetDisplays(Ref count) => T.GetDisplays(count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => T.GetRectIntersectionFloat(A, B, result); + public byte GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => T.GetDisplayUsableBounds(displayID, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) => T.GetRectIntersectionFloat(A, B, result); + public MaybeBool GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) => T.GetDisplayUsableBounds(displayID, rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => T.GetRectUnion(A, B, result); + public sbyte* Getenv([NativeTypeName("const char *")] sbyte* name) => T.Getenv(name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) => T.GetRectUnion(A, B, result); + public Ptr Getenv([NativeTypeName("const char *")] Ref name) => + T.Getenv(name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => T.GetRectUnionFloat(A, B, result); + public sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + T.GetenvUnsafe(name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) => T.GetRectUnionFloat(A, B, result); + public Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name) => + T.GetenvUnsafe(name); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetRelativeMouseState(float* x, float* y) => T.GetRelativeMouseState(x, y); + public EnvironmentHandle GetEnvironment() => T.GetEnvironment(); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetRelativeMouseState(Ref x, Ref y) => - T.GetRelativeMouseState(x, y); + public sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => T.GetEnvironmentVariable(env, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => - T.GetRenderClipRect(renderer, rect); + public Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) => T.GetEnvironmentVariable(env, name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) => - T.GetRenderClipRect(renderer, rect); + public Ptr2D GetEnvironmentVariables(EnvironmentHandle env) => + T.GetEnvironmentVariables(env); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderColorScale(RendererHandle renderer, float* scale) => - T.GetRenderColorScale(renderer, scale); + public sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env) => + T.GetEnvironmentVariablesRaw(env); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) => - T.GetRenderColorScale(renderer, scale); + public Ptr GetError() => T.GetError(); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public sbyte* GetErrorRaw() => T.GetErrorRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => T.GetRenderDrawBlendMode(renderer, blendMode); + public byte GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, + void** userdata + ) => T.GetEventFilter(filter, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => T.GetRenderDrawBlendMode(renderer, blendMode); + public MaybeBool GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] Ref filter, + Ref2D userdata + ) => T.GetEventFilter(filter, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => T.GetRenderDrawColor(renderer, r, g, b, a); + public float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float default_value + ) => T.GetFloatProperty(props, name, default_value); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => T.GetRenderDrawColor(renderer, r, g, b, a); + public float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float default_value + ) => T.GetFloatProperty(props, name, default_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderDrawColorFloat( - RendererHandle renderer, - float* r, - float* g, - float* b, - float* a - ) => T.GetRenderDrawColorFloat(renderer, r, g, b, a); + public DisplayMode** GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int* count + ) => T.GetFullscreenDisplayModes(displayID, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderDrawColorFloat( - RendererHandle renderer, - Ref r, - Ref g, - Ref b, - Ref a - ) => T.GetRenderDrawColorFloat(renderer, r, g, b, a); + public Ptr2D GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref count + ) => T.GetFullscreenDisplayModes(displayID, count); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRenderDriver(int index) => T.GetRenderDriver(index); + public Ptr GetGamepadAppleSFSymbolsNameForAxis( + GamepadHandle gamepad, + GamepadAxis axis + ) => T.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetRenderDriverRaw(int index) => T.GetRenderDriverRaw(index); + public sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( + GamepadHandle gamepad, + GamepadAxis axis + ) => T.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle GetRenderer(WindowHandle window) => T.GetRenderer(window); + public Ptr GetGamepadAppleSFSymbolsNameForButton( + GamepadHandle gamepad, + GamepadButton button + ) => T.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle GetRendererFromTexture(Texture* texture) => - T.GetRendererFromTexture(texture); + public sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( + GamepadHandle gamepad, + GamepadButton button + ) => T.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public RendererHandle GetRendererFromTexture(Ref texture) => - T.GetRendererFromTexture(texture); + public short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => + T.GetGamepadAxis(gamepad, axis); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRendererName(RendererHandle renderer) => T.GetRendererName(renderer); + public GamepadAxis GetGamepadAxisFromString([NativeTypeName("const char *")] sbyte* str) => + T.GetGamepadAxisFromString(str); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetRendererNameRaw(RendererHandle renderer) => T.GetRendererNameRaw(renderer); + public GamepadAxis GetGamepadAxisFromString( + [NativeTypeName("const char *")] Ref str + ) => T.GetGamepadAxisFromString(str); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetRendererProperties(RendererHandle renderer) => - T.GetRendererProperties(renderer); + public GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => + T.GetGamepadBindings(gamepad, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderLogicalPresentation( - RendererHandle renderer, - int* w, - int* h, - RendererLogicalPresentation* mode - ) => T.GetRenderLogicalPresentation(renderer, w, h, mode); + public Ptr2D GetGamepadBindings(GamepadHandle gamepad, Ref count) => + T.GetGamepadBindings(gamepad, count); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderLogicalPresentation( - RendererHandle renderer, - Ref w, - Ref h, - Ref mode - ) => T.GetRenderLogicalPresentation(renderer, w, h, mode); + public MaybeBool GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => + T.GetGamepadButton(gamepad, button); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => - T.GetRenderLogicalPresentationRect(renderer, rect); + public GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] sbyte* str + ) => T.GetGamepadButtonFromString(str); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderLogicalPresentationRect( - RendererHandle renderer, - Ref rect - ) => T.GetRenderLogicalPresentationRect(renderer, rect); + public GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] Ref str + ) => T.GetGamepadButtonFromString(str); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => - T.GetRenderMetalCommandEncoder(renderer); + public GamepadButtonLabel GetGamepadButtonLabel( + GamepadHandle gamepad, + GamepadButton button + ) => T.GetGamepadButtonLabel(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => - T.GetRenderMetalCommandEncoderRaw(renderer); + public GamepadButtonLabel GetGamepadButtonLabelForType( + GamepadType type, + GamepadButton button + ) => T.GetGamepadButtonLabelForType(type, button); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRenderMetalLayer(RendererHandle renderer) => T.GetRenderMetalLayer(renderer); + public byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => + T.GetGamepadButtonRaw(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetRenderMetalLayerRaw(RendererHandle renderer) => - T.GetRenderMetalLayerRaw(renderer); + public JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => + T.GetGamepadConnectionState(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => - T.GetRenderOutputSize(renderer, w, h); + public ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => + T.GetGamepadFirmwareVersion(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h - ) => T.GetRenderOutputSize(renderer, w, h); + public GamepadHandle GetGamepadFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadFromID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => - T.GetRenderSafeArea(renderer, rect); + public GamepadHandle GetGamepadFromPlayerIndex(int player_index) => + T.GetGamepadFromPlayerIndex(player_index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) => - T.GetRenderSafeArea(renderer, rect); + public Guid GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetGamepadGuidForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => - T.GetRenderScale(renderer, scaleX, scaleY); + public uint GetGamepadID(GamepadHandle gamepad) => T.GetGamepadID(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderScale( - RendererHandle renderer, - Ref scaleX, - Ref scaleY - ) => T.GetRenderScale(renderer, scaleX, scaleY); + public JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => + T.GetGamepadJoystick(gamepad); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRenderTarget(RendererHandle renderer) => T.GetRenderTarget(renderer); + public Ptr GetGamepadMapping(GamepadHandle gamepad) => T.GetGamepadMapping(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Texture* GetRenderTargetRaw(RendererHandle renderer) => - T.GetRenderTargetRaw(renderer); + public Ptr GetGamepadMappingForGuid(Guid guid) => T.GetGamepadMappingForGuid(guid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderViewport(RendererHandle renderer, Rect* rect) => - T.GetRenderViewport(renderer, rect); + public sbyte* GetGamepadMappingForGuidRaw(Guid guid) => T.GetGamepadMappingForGuidRaw(guid); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) => - T.GetRenderViewport(renderer, rect); + public Ptr GetGamepadMappingForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadMappingForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetRenderVSync(RendererHandle renderer, int* vsync) => - T.GetRenderVSync(renderer, vsync); + public sbyte* GetGamepadMappingForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadMappingForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) => - T.GetRenderVSync(renderer, vsync); + public sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => + T.GetGamepadMappingRaw(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetRenderWindow(RendererHandle renderer) => T.GetRenderWindow(renderer); + public sbyte** GetGamepadMappings(int* count) => T.GetGamepadMappings(count); + + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public Ptr2D GetGamepadMappings(Ref count) => T.GetGamepadMappings(count); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetRevision() => T.GetRevision(); + public Ptr GetGamepadName(GamepadHandle gamepad) => T.GetGamepadName(gamepad); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetRevisionRaw() => T.GetRevisionRaw(); + public Ptr GetGamepadNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadNameForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => T.GetRGB(pixel, format, palette, r, g, b); + public sbyte* GetGamepadNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetGamepadNameForIDRaw(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => T.GetRGB(pixel, format, palette, r, g, b); + public sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => T.GetGamepadNameRaw(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => T.GetRgba(pixel, format, palette, r, g, b, a); + public Ptr GetGamepadPath(GamepadHandle gamepad) => T.GetGamepadPath(gamepad); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => T.GetRgba(pixel, format, palette, r, g, b, a); + public Ptr GetGamepadPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadPathForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Sandbox GetSandbox() => T.GetSandbox(); + public sbyte* GetGamepadPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetGamepadPathForIDRaw(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] ushort* modstate - ) => T.GetScancodeFromKey(key, modstate); + public sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => T.GetGamepadPathRaw(gamepad); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] Ref modstate - ) => T.GetScancodeFromKey(key, modstate); + public int GetGamepadPlayerIndex(GamepadHandle gamepad) => T.GetGamepadPlayerIndex(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => - T.GetScancodeFromName(name); + public int GetGamepadPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadPlayerIndexForID(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) => - T.GetScancodeFromName(name); + public PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => + T.GetGamepadPowerInfo(gamepad, percent); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetScancodeName(Scancode scancode) => T.GetScancodeName(scancode); + public PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) => + T.GetGamepadPowerInfo(gamepad, percent); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetScancodeNameRaw(Scancode scancode) => T.GetScancodeNameRaw(scancode); + public ushort GetGamepadProduct(GamepadHandle gamepad) => T.GetGamepadProduct(gamepad); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetSemaphoreValue(SemaphoreHandle sem) => T.GetSemaphoreValue(sem); + public ushort GetGamepadProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetGamepadProductForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSensorData(SensorHandle sensor, float* data, int num_values) => - T.GetSensorData(sensor, data, num_values); + public ushort GetGamepadProductVersion(GamepadHandle gamepad) => + T.GetGamepadProductVersion(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSensorData( - SensorHandle sensor, - Ref data, - int num_values - ) => T.GetSensorData(sensor, data, num_values); + public ushort GetGamepadProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadProductVersionForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SensorHandle GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => - T.GetSensorFromID(instance_id); + public uint GetGamepadProperties(GamepadHandle gamepad) => T.GetGamepadProperties(gamepad); - [return: NativeTypeName("SDL_SensorID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetSensorID(SensorHandle sensor) => T.GetSensorID(sensor); + public uint* GetGamepads(int* count) => T.GetGamepads(count); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("SDL_JoystickID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetSensorName(SensorHandle sensor) => T.GetSensorName(sensor); + public Ptr GetGamepads(Ref count) => T.GetGamepads(count); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetSensorNameForID([NativeTypeName("SDL_SensorID")] uint instance_id) => - T.GetSensorNameForID(instance_id); + public byte GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + float* data, + int num_values + ) => T.GetGamepadSensorData(gamepad, type, data, num_values); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => - T.GetSensorNameForIDRaw(instance_id); + public MaybeBool GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + Ref data, + int num_values + ) => T.GetGamepadSensorData(gamepad, type, data, num_values); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetSensorNameRaw(SensorHandle sensor) => T.GetSensorNameRaw(sensor); + public float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => + T.GetGamepadSensorDataRate(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetSensorNonPortableType(SensorHandle sensor) => - T.GetSensorNonPortableType(sensor); + public Ptr GetGamepadSerial(GamepadHandle gamepad) => T.GetGamepadSerial(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetSensorNonPortableTypeForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => T.GetSensorNonPortableTypeForID(instance_id); + public sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => T.GetGamepadSerialRaw(gamepad); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetSensorProperties(SensorHandle sensor) => T.GetSensorProperties(sensor); + public ulong GetGamepadSteamHandle(GamepadHandle gamepad) => + T.GetGamepadSteamHandle(gamepad); - [return: NativeTypeName("SDL_SensorID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint* GetSensors(int* count) => T.GetSensors(count); + public Ptr GetGamepadStringForAxis(GamepadAxis axis) => + T.GetGamepadStringForAxis(axis); - [return: NativeTypeName("SDL_SensorID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetSensors(Ref count) => T.GetSensors(count); + public sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => + T.GetGamepadStringForAxisRaw(axis); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SensorType GetSensorType(SensorHandle sensor) => T.GetSensorType(sensor); + public Ptr GetGamepadStringForButton(GamepadButton button) => + T.GetGamepadStringForButton(button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SensorType GetSensorTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => - T.GetSensorTypeForID(instance_id); + public sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => + T.GetGamepadStringForButtonRaw(button); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetSilenceValueForFormat(AudioFormat format) => - T.GetSilenceValueForFormat(format); + public Ptr GetGamepadStringForType(GamepadType type) => + T.GetGamepadStringForType(type); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint GetSimdAlignment() => T.GetSimdAlignment(); + public sbyte* GetGamepadStringForTypeRaw(GamepadType type) => + T.GetGamepadStringForTypeRaw(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("Uint64 *")] ulong* length - ) => T.GetStorageFileSize(storage, path, length); + public byte GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + bool* down, + float* x, + float* y, + float* pressure + ) => T.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("Uint64 *")] Ref length - ) => T.GetStorageFileSize(storage, path, length); + public MaybeBool GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + Ref down, + Ref x, + Ref y, + Ref pressure + ) => T.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - PathInfo* info - ) => T.GetStoragePathInfo(storage, path, info); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref info - ) => T.GetStoragePathInfo(storage, path, info); + public GamepadType GetGamepadType(GamepadHandle gamepad) => T.GetGamepadType(gamepad); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetStorageSpaceRemaining(StorageHandle storage) => - T.GetStorageSpaceRemaining(storage); + public GamepadType GetGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetGamepadTypeForID(instance_id); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* default_value - ) => T.GetStringProperty(props, name, default_value); + public GamepadType GetGamepadTypeFromString([NativeTypeName("const char *")] sbyte* str) => + T.GetGamepadTypeFromString(str); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref default_value - ) => T.GetStringProperty(props, name, default_value); + public GamepadType GetGamepadTypeFromString( + [NativeTypeName("const char *")] Ref str + ) => T.GetGamepadTypeFromString(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8 *")] byte* alpha) => - T.GetSurfaceAlphaMod(surface, alpha); + public ushort GetGamepadVendor(GamepadHandle gamepad) => T.GetGamepadVendor(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref alpha - ) => T.GetSurfaceAlphaMod(surface, alpha); + public ushort GetGamepadVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetGamepadVendorForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => T.GetSurfaceBlendMode(surface, blendMode); + public uint GetGlobalMouseState(float* x, float* y) => T.GetGlobalMouseState(x, y); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => T.GetSurfaceBlendMode(surface, blendMode); + public uint GetGlobalMouseState(Ref x, Ref y) => T.GetGlobalMouseState(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSurfaceClipRect(Surface* surface, Rect* rect) => - T.GetSurfaceClipRect(surface, rect); + public uint GetGlobalProperties() => T.GetGlobalProperties(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) => - T.GetSurfaceClipRect(surface, rect); + public Ptr GetGPUDeviceDriver(GPUDeviceHandle device) => + T.GetGPUDeviceDriver(device); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSurfaceColorKey(Surface* surface, [NativeTypeName("Uint32 *")] uint* key) => - T.GetSurfaceColorKey(surface, key); + public sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device) => + T.GetGPUDeviceDriverRaw(device); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSurfaceColorKey( - Ref surface, - [NativeTypeName("Uint32 *")] Ref key - ) => T.GetSurfaceColorKey(surface, key); + public Ptr GetGPUDriver(int index) => T.GetGPUDriver(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => T.GetSurfaceColorMod(surface, r, g, b); + public sbyte* GetGPUDriverRaw(int index) => T.GetGPUDriverRaw(index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [return: NativeTypeName("SDL_GPUShaderFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => T.GetSurfaceColorMod(surface, r, g, b); + public uint GetGPUShaderFormats(GPUDeviceHandle device) => T.GetGPUShaderFormats(device); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Colorspace GetSurfaceColorspace(Surface* surface) => T.GetSurfaceColorspace(surface); + public GPUTextureFormat GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ) => T.GetGPUSwapchainTextureFormat(device, window); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public WindowHandle GetGrabbedWindow() => T.GetGrabbedWindow(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Colorspace GetSurfaceColorspace(Ref surface) => - T.GetSurfaceColorspace(surface); + public MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => + T.GetHapticEffectStatus(haptic, effect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface** GetSurfaceImages(Surface* surface, int* count) => - T.GetSurfaceImages(surface, count); + public byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => + T.GetHapticEffectStatusRaw(haptic, effect); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetSurfaceImages(Ref surface, Ref count) => - T.GetSurfaceImages(surface, count); + public uint GetHapticFeatures(HapticHandle haptic) => T.GetHapticFeatures(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Palette* GetSurfacePalette(Surface* surface) => T.GetSurfacePalette(surface); + public HapticHandle GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => + T.GetHapticFromID(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [return: NativeTypeName("SDL_HapticID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetSurfacePalette(Ref surface) => T.GetSurfacePalette(surface); + public uint GetHapticID(HapticHandle haptic) => T.GetHapticID(haptic); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetSurfaceProperties(Surface* surface) => T.GetSurfaceProperties(surface); + public Ptr GetHapticName(HapticHandle haptic) => T.GetHapticName(haptic); - [return: NativeTypeName("SDL_PropertiesID")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetSurfaceProperties(Ref surface) => T.GetSurfaceProperties(surface); + public Ptr GetHapticNameForID([NativeTypeName("SDL_HapticID")] uint instance_id) => + T.GetHapticNameForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetSystemRAM() => T.GetSystemRAM(); + public sbyte* GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => + T.GetHapticNameForIDRaw(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SystemTheme GetSystemTheme() => T.GetSystemTheme(); + public sbyte* GetHapticNameRaw(HapticHandle haptic) => T.GetHapticNameRaw(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [return: NativeTypeName("SDL_HapticID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => - T.GetTextInputArea(window, rect, cursor); + public uint* GetHaptics(int* count) => T.GetHaptics(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_HapticID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextInputArea( - WindowHandle window, - Ref rect, - Ref cursor - ) => T.GetTextInputArea(window, rect, cursor); + public Ptr GetHaptics(Ref count) => T.GetHaptics(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8 *")] byte* alpha) => - T.GetTextureAlphaMod(texture, alpha); + public sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => T.GetHint(name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref alpha - ) => T.GetTextureAlphaMod(texture, alpha); + public Ptr GetHint([NativeTypeName("const char *")] Ref name) => + T.GetHint(name); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => - T.GetTextureAlphaModFloat(texture, alpha); + public byte GetHintBoolean( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value + ) => T.GetHintBoolean(name, default_value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureAlphaModFloat(Ref texture, Ref alpha) => - T.GetTextureAlphaModFloat(texture, alpha); + public MaybeBool GetHintBoolean( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value + ) => T.GetHintBoolean(name, default_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => T.GetTextureBlendMode(texture, blendMode); + public uint GetIOProperties(IOStreamHandle context) => T.GetIOProperties(context); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => T.GetTextureBlendMode(texture, blendMode); + public long GetIOSize(IOStreamHandle context) => T.GetIOSize(context); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => T.GetTextureColorMod(texture, r, g, b); + public IOStatus GetIOStatus(IOStreamHandle context) => T.GetIOStatus(context); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => T.GetTextureColorMod(texture, r, g, b); + public short GetJoystickAxis(JoystickHandle joystick, int axis) => + T.GetJoystickAxis(joystick, axis); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => - T.GetTextureColorModFloat(texture, r, g, b); + public byte GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] short* state + ) => T.GetJoystickAxisInitialState(joystick, axis, state); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool GetTextureColorModFloat( - Ref texture, - Ref r, - Ref g, - Ref b - ) => T.GetTextureColorModFloat(texture, r, g, b); - - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetTextureProperties(Texture* texture) => T.GetTextureProperties(texture); + public MaybeBool GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] Ref state + ) => T.GetJoystickAxisInitialState(joystick, axis, state); - [return: NativeTypeName("SDL_PropertiesID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetTextureProperties(Ref texture) => T.GetTextureProperties(texture); + public byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => + T.GetJoystickBall(joystick, ball, dx, dy); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => - T.GetTextureScaleMode(texture, scaleMode); + public MaybeBool GetJoystickBall( + JoystickHandle joystick, + int ball, + Ref dx, + Ref dy + ) => T.GetJoystickBall(joystick, ball, dx, dy); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureScaleMode( - Ref texture, - Ref scaleMode - ) => T.GetTextureScaleMode(texture, scaleMode); + public MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => + T.GetJoystickButton(joystick, button); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetTextureSize(Texture* texture, float* w, float* h) => - T.GetTextureSize(texture, w, h); + public byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => + T.GetJoystickButtonRaw(joystick, button); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetTextureSize(Ref texture, Ref w, Ref h) => - T.GetTextureSize(texture, w, h); + public JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => + T.GetJoystickConnectionState(joystick); - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetThreadID(ThreadHandle thread) => T.GetThreadID(thread); + public ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => + T.GetJoystickFirmwareVersion(joystick); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetThreadName(ThreadHandle thread) => T.GetThreadName(thread); + public JoystickHandle GetJoystickFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickFromID(instance_id); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetThreadNameRaw(ThreadHandle thread) => T.GetThreadNameRaw(thread); + public JoystickHandle GetJoystickFromPlayerIndex(int player_index) => + T.GetJoystickFromPlayerIndex(player_index); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetTicks() => T.GetTicks(); + public Guid GetJoystickGuid(JoystickHandle joystick) => T.GetJoystickGuid(joystick); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetTicksNS() => T.GetTicksNS(); + public Guid GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetJoystickGuidForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => T.GetTLS(id); + public void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] ushort* vendor, + [NativeTypeName("Uint16 *")] ushort* product, + [NativeTypeName("Uint16 *")] ushort* version, + [NativeTypeName("Uint16 *")] ushort* crc16 + ) => T.GetJoystickGuidInfo(guid, vendor, product, version, crc16); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) => T.GetTLS(id); + public void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] Ref vendor, + [NativeTypeName("Uint16 *")] Ref product, + [NativeTypeName("Uint16 *")] Ref version, + [NativeTypeName("Uint16 *")] Ref crc16 + ) => T.GetJoystickGuidInfo(guid, vendor, product, version, crc16); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [return: NativeTypeName("Uint8")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => - T.GetTouchDeviceName(touchID); + public byte GetJoystickHat(JoystickHandle joystick, int hat) => + T.GetJoystickHat(joystick, hat); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => - T.GetTouchDeviceNameRaw(touchID); + public uint GetJoystickID(JoystickHandle joystick) => T.GetJoystickID(joystick); - [return: NativeTypeName("SDL_TouchID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong* GetTouchDevices(int* count) => T.GetTouchDevices(count); + public Ptr GetJoystickName(JoystickHandle joystick) => T.GetJoystickName(joystick); - [return: NativeTypeName("SDL_TouchID *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetTouchDevices(Ref count) => T.GetTouchDevices(count); + public Ptr GetJoystickNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickNameForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public TouchDeviceType GetTouchDeviceType([NativeTypeName("SDL_TouchID")] ulong touchID) => - T.GetTouchDeviceType(touchID); + public sbyte* GetJoystickNameForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickNameForIDRaw(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Finger** GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - int* count - ) => T.GetTouchFingers(touchID, count); + public sbyte* GetJoystickNameRaw(JoystickHandle joystick) => T.GetJoystickNameRaw(joystick); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - Ref count - ) => T.GetTouchFingers(touchID, count); + public Ptr GetJoystickPath(JoystickHandle joystick) => T.GetJoystickPath(joystick); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetUserFolder(Folder folder) => T.GetUserFolder(folder); + public Ptr GetJoystickPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickPathForID(instance_id); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetUserFolderRaw(Folder folder) => T.GetUserFolderRaw(folder); + public sbyte* GetJoystickPathForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickPathForIDRaw(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int GetVersion() => T.GetVersion(); + public sbyte* GetJoystickPathRaw(JoystickHandle joystick) => T.GetJoystickPathRaw(joystick); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetVideoDriver(int index) => T.GetVideoDriver(index); + public int GetJoystickPlayerIndex(JoystickHandle joystick) => + T.GetJoystickPlayerIndex(joystick); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetVideoDriverRaw(int index) => T.GetVideoDriverRaw(index); + public int GetJoystickPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickPlayerIndexForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowAspectRatio( - WindowHandle window, - float* min_aspect, - float* max_aspect - ) => T.GetWindowAspectRatio(window, min_aspect, max_aspect); + public PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => + T.GetJoystickPowerInfo(joystick, percent); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowAspectRatio( - WindowHandle window, - Ref min_aspect, - Ref max_aspect - ) => T.GetWindowAspectRatio(window, min_aspect, max_aspect); + public PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) => + T.GetJoystickPowerInfo(joystick, percent); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowBordersSize( - WindowHandle window, - int* top, - int* left, - int* bottom, - int* right - ) => T.GetWindowBordersSize(window, top, left, bottom, right); + public ushort GetJoystickProduct(JoystickHandle joystick) => T.GetJoystickProduct(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowBordersSize( - WindowHandle window, - Ref top, - Ref left, - Ref bottom, - Ref right - ) => T.GetWindowBordersSize(window, top, left, bottom, right); + public ushort GetJoystickProductForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickProductForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetWindowDisplayScale(WindowHandle window) => T.GetWindowDisplayScale(window); + public ushort GetJoystickProductVersion(JoystickHandle joystick) => + T.GetJoystickProductVersion(joystick); - [return: NativeTypeName("SDL_WindowFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public ulong GetWindowFlags(WindowHandle window) => T.GetWindowFlags(window); + public ushort GetJoystickProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickProductVersionForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Event* @event - ) => T.GetWindowFromEvent(@event); + public uint GetJoystickProperties(JoystickHandle joystick) => + T.GetJoystickProperties(joystick); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Ref @event - ) => T.GetWindowFromEvent(@event); + public uint* GetJoysticks(int* count) => T.GetJoysticks(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] + [return: NativeTypeName("SDL_JoystickID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => - T.GetWindowFromID(id); + public Ptr GetJoysticks(Ref count) => T.GetJoysticks(count); - [return: NativeTypeName("const SDL_DisplayMode *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindowFullscreenMode(WindowHandle window) => - T.GetWindowFullscreenMode(window); + public Ptr GetJoystickSerial(JoystickHandle joystick) => + T.GetJoystickSerial(joystick); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => - T.GetWindowFullscreenModeRaw(window); + public sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => + T.GetJoystickSerialRaw(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* GetWindowICCProfile( - WindowHandle window, - [NativeTypeName("size_t *")] nuint* size - ) => T.GetWindowICCProfile(window, size); + public JoystickType GetJoystickType(JoystickHandle joystick) => T.GetJoystickType(joystick); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindowICCProfile( - WindowHandle window, - [NativeTypeName("size_t *")] Ref size - ) => T.GetWindowICCProfile(window, size); + public JoystickType GetJoystickTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetJoystickTypeForID(instance_id); - [return: NativeTypeName("SDL_WindowID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetWindowID(WindowHandle window) => T.GetWindowID(window); + public ushort GetJoystickVendor(JoystickHandle joystick) => T.GetJoystickVendor(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowKeyboardGrab(WindowHandle window) => - T.GetWindowKeyboardGrab(window); + public ushort GetJoystickVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.GetJoystickVendorForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowKeyboardGrabRaw(WindowHandle window) => - T.GetWindowKeyboardGrabRaw(window); + public WindowHandle GetKeyboardFocus() => T.GetKeyboardFocus(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => - T.GetWindowMaximumSize(window, w, h); + public Ptr GetKeyboardNameForID( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => T.GetKeyboardNameForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowMaximumSize(WindowHandle window, Ref w, Ref h) => - T.GetWindowMaximumSize(window, w, h); + public sbyte* GetKeyboardNameForIDRaw( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => T.GetKeyboardNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [return: NativeTypeName("SDL_KeyboardID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => - T.GetWindowMinimumSize(window, w, h); + public uint* GetKeyboards(int* count) => T.GetKeyboards(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_KeyboardID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowMinimumSize(WindowHandle window, Ref w, Ref h) => - T.GetWindowMinimumSize(window, w, h); + public Ptr GetKeyboards(Ref count) => T.GetKeyboards(count); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [return: NativeTypeName("const bool *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowMouseGrab(WindowHandle window) => - T.GetWindowMouseGrab(window); + public bool* GetKeyboardState(int* numkeys) => T.GetKeyboardState(numkeys); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [return: NativeTypeName("const bool *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowMouseGrabRaw(WindowHandle window) => T.GetWindowMouseGrabRaw(window); + public Ptr GetKeyboardState(Ref numkeys) => T.GetKeyboardState(numkeys); - [return: NativeTypeName("const SDL_Rect *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindowMouseRect(WindowHandle window) => T.GetWindowMouseRect(window); + public uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => + T.GetKeyFromName(name); - [return: NativeTypeName("const SDL_Rect *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [return: NativeTypeName("SDL_Keycode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Rect* GetWindowMouseRectRaw(WindowHandle window) => T.GetWindowMouseRectRaw(window); + public uint GetKeyFromName([NativeTypeName("const char *")] Ref name) => + T.GetKeyFromName(name); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetWindowOpacity(WindowHandle window) => T.GetWindowOpacity(window); + public uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] byte key_event + ) => T.GetKeyFromScancode(scancode, modstate, key_event); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] + [return: NativeTypeName("SDL_Keycode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GetWindowParent(WindowHandle window) => T.GetWindowParent(window); + public uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] MaybeBool key_event + ) => T.GetKeyFromScancode(scancode, modstate, key_event); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public float GetWindowPixelDensity(WindowHandle window) => T.GetWindowPixelDensity(window); + public Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => T.GetKeyName(key); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public PixelFormat GetWindowPixelFormat(WindowHandle window) => - T.GetWindowPixelFormat(window); + public sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => + T.GetKeyNameRaw(key); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowPosition(WindowHandle window, int* x, int* y) => - T.GetWindowPosition(window, x, y); + public void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, + void** userdata + ) => T.GetLogOutputFunction(callback, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) => - T.GetWindowPosition(window, x, y); + public void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, + Ref2D userdata + ) => T.GetLogOutputFunction(callback, userdata); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint GetWindowProperties(WindowHandle window) => T.GetWindowProperties(window); + public LogPriority GetLogPriority(int category) => T.GetLogPriority(category); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => - T.GetWindowRelativeMouseMode(window); + public byte GetMasksForPixelFormat( + PixelFormat format, + int* bpp, + [NativeTypeName("Uint32 *")] uint* Rmask, + [NativeTypeName("Uint32 *")] uint* Gmask, + [NativeTypeName("Uint32 *")] uint* Bmask, + [NativeTypeName("Uint32 *")] uint* Amask + ) => T.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowRelativeMouseModeRaw(WindowHandle window) => - T.GetWindowRelativeMouseModeRaw(window); + public MaybeBool GetMasksForPixelFormat( + PixelFormat format, + Ref bpp, + [NativeTypeName("Uint32 *")] Ref Rmask, + [NativeTypeName("Uint32 *")] Ref Gmask, + [NativeTypeName("Uint32 *")] Ref Bmask, + [NativeTypeName("Uint32 *")] Ref Amask + ) => T.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle* GetWindows(int* count) => T.GetWindows(count); + public int GetMaxHapticEffects(HapticHandle haptic) => T.GetMaxHapticEffects(haptic); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindows(Ref count) => T.GetWindows(count); + public int GetMaxHapticEffectsPlaying(HapticHandle haptic) => + T.GetMaxHapticEffectsPlaying(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowSafeArea(WindowHandle window, Rect* rect) => - T.GetWindowSafeArea(window, rect); + public void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => T.GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) => - T.GetWindowSafeArea(window, rect); + public void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) => T.GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [return: NativeTypeName("SDL_MouseID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowSize(WindowHandle window, int* w, int* h) => - T.GetWindowSize(window, w, h); + public uint* GetMice(int* count) => T.GetMice(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) => - T.GetWindowSize(window, w, h); + public Ptr GetMice(Ref count) => T.GetMice(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [return: NativeTypeName("SDL_Keymod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => - T.GetWindowSizeInPixels(window, w, h); + public ushort GetModState() => T.GetModState(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowSizeInPixels(WindowHandle window, Ref w, Ref h) => - T.GetWindowSizeInPixels(window, w, h); + public WindowHandle GetMouseFocus() => T.GetMouseFocus(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindowSurface(WindowHandle window) => T.GetWindowSurface(window); + public Ptr GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => + T.GetMouseNameForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* GetWindowSurfaceRaw(WindowHandle window) => T.GetWindowSurfaceRaw(window); + public sbyte* GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => + T.GetMouseNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => - T.GetWindowSurfaceVSync(window, vsync); + public uint GetMouseState(float* x, float* y) => T.GetMouseState(x, y); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) => - T.GetWindowSurfaceVSync(window, vsync); + public uint GetMouseState(Ref x, Ref y) => T.GetMouseState(x, y); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr GetWindowTitle(WindowHandle window) => T.GetWindowTitle(window); + public DisplayOrientation GetNaturalDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => T.GetNaturalDisplayOrientation(displayID); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAllocations")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte* GetWindowTitleRaw(WindowHandle window) => T.GetWindowTitleRaw(window); + public int GetNumAllocations() => T.GetNumAllocations(); - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GLContextStateHandle GLCreateContext(WindowHandle window) => - T.GLCreateContext(window); + public int GetNumAudioDrivers() => T.GetNumAudioDrivers(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLDestroyContext( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => T.GLDestroyContext(context); + public long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long default_value + ) => T.GetNumberProperty(props, name, default_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [return: NativeTypeName("Sint64")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLDestroyContextRaw( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => T.GLDestroyContextRaw(context); + public long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long default_value + ) => T.GetNumberProperty(props, name, default_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => - T.GLExtensionSupported(extension); + public int GetNumCameraDrivers() => T.GetNumCameraDrivers(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLExtensionSupported( - [NativeTypeName("const char *")] Ref extension - ) => T.GLExtensionSupported(extension); + public int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => + T.GetNumGamepadTouchpadFingers(gamepad, touchpad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLGetAttribute(GLAttr attr, int* value) => T.GLGetAttribute(attr, value); + public int GetNumGamepadTouchpads(GamepadHandle gamepad) => + T.GetNumGamepadTouchpads(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGPUDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLGetAttribute(GLAttr attr, Ref value) => - T.GLGetAttribute(attr, value); + public int GetNumGPUDrivers() => T.GetNumGPUDrivers(); - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GLContextStateHandle GLGetCurrentContext() => T.GLGetCurrentContext(); + public int GetNumHapticAxes(HapticHandle haptic) => T.GetNumHapticAxes(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public WindowHandle GLGetCurrentWindow() => T.GLGetCurrentWindow(); + public int GetNumJoystickAxes(JoystickHandle joystick) => T.GetNumJoystickAxes(joystick); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => - T.GLGetProcAddress(proc); + public int GetNumJoystickBalls(JoystickHandle joystick) => T.GetNumJoystickBalls(joystick); - [return: NativeTypeName("SDL_FunctionPointer")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] Ref proc) => - T.GLGetProcAddress(proc); + public int GetNumJoystickButtons(JoystickHandle joystick) => + T.GetNumJoystickButtons(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLGetSwapInterval(int* interval) => T.GLGetSwapInterval(interval); + public int GetNumJoystickHats(JoystickHandle joystick) => T.GetNumJoystickHats(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLGetSwapInterval(Ref interval) => - T.GLGetSwapInterval(interval); + public int GetNumLogicalCPUCores() => T.GetNumLogicalCPUCores(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => - T.GLLoadLibrary(path); + public int GetNumRenderDrivers() => T.GetNumRenderDrivers(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLLoadLibrary([NativeTypeName("const char *")] Ref path) => - T.GLLoadLibrary(path); + public int GetNumVideoDrivers() => T.GetNumVideoDrivers(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLMakeCurrent( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => T.GLMakeCurrent(window, context); + public void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => T.GetOriginalMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLMakeCurrentRaw( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => T.GLMakeCurrentRaw(window, context); + public void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) => T.GetOriginalMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GLResetAttributes() => T.GLResetAttributes(); + public byte GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => + T.GetPathInfo(path, info); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLSetAttribute(GLAttr attr, int value) => - T.GLSetAttribute(attr, value); + public MaybeBool GetPathInfo( + [NativeTypeName("const char *")] Ref path, + Ref info + ) => T.GetPathInfo(path, info); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLSetAttributeRaw(GLAttr attr, int value) => T.GLSetAttributeRaw(attr, value); + public ulong GetPerformanceCounter() => T.GetPerformanceCounter(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLSetSwapInterval(int interval) => T.GLSetSwapInterval(interval); + public ulong GetPerformanceFrequency() => T.GetPerformanceFrequency(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLSetSwapIntervalRaw(int interval) => T.GLSetSwapIntervalRaw(interval); + public Ptr GetPixelFormatDetails(PixelFormat format) => + T.GetPixelFormatDetails(format); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool GLSwapWindow(WindowHandle window) => T.GLSwapWindow(window); + public PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => + T.GetPixelFormatDetailsRaw(format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte GLSwapWindowRaw(WindowHandle window) => T.GLSwapWindowRaw(window); - - [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] + public PixelFormat GetPixelFormatForMasks( + int bpp, + [NativeTypeName("Uint32")] uint Rmask, + [NativeTypeName("Uint32")] uint Gmask, + [NativeTypeName("Uint32")] uint Bmask, + [NativeTypeName("Uint32")] uint Amask + ) => T.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GLUnloadLibrary() => T.GLUnloadLibrary(); + public Ptr GetPixelFormatName(PixelFormat format) => T.GetPixelFormatName(format); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte** GlobDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => T.GlobDirectory(path, pattern, flags, count); + public sbyte* GetPixelFormatNameRaw(PixelFormat format) => T.GetPixelFormatNameRaw(format); - [return: NativeTypeName("char **")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GlobDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) => T.GlobDirectory(path, pattern, flags, count); + public Ptr GetPlatform() => T.GetPlatform(); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public sbyte** GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => T.GlobStorageDirectory(storage, path, pattern, flags, count); + public sbyte* GetPlatformRaw() => T.GetPlatformRaw(); - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr2D GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) => T.GlobStorageDirectory(storage, path, pattern, flags, count); + public void* GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* default_value + ) => T.GetPointerProperty(props, name, default_value); - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GuidToString( - Guid guid, - [NativeTypeName("char *")] sbyte* pszGUID, - int cbGUID - ) => T.GuidToString(guid, pszGUID, cbGUID); + public Ptr GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref default_value + ) => T.GetPointerProperty(props, name, default_value); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void GuidToString( - Guid guid, - [NativeTypeName("char *")] Ref pszGUID, - int cbGUID - ) => T.GuidToString(guid, pszGUID, cbGUID); + public PowerState GetPowerInfo(int* seconds, int* percent) => + T.GetPowerInfo(seconds, percent); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => T.HapticEffectSupported(haptic, effect); + public PowerState GetPowerInfo(Ref seconds, Ref percent) => + T.GetPowerInfo(seconds, percent); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) => T.HapticEffectSupported(haptic, effect); + public Locale** GetPreferredLocales(int* count) => T.GetPreferredLocales(count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HapticRumbleSupported(HapticHandle haptic) => - T.HapticRumbleSupported(haptic); + public Ptr2D GetPreferredLocales(Ref count) => T.GetPreferredLocales(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HapticRumbleSupportedRaw(HapticHandle haptic) => - T.HapticRumbleSupportedRaw(haptic); + public sbyte* GetPrefPath( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app + ) => T.GetPrefPath(org, app); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasAltiVec() => T.HasAltiVec(); + public Ptr GetPrefPath( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app + ) => T.GetPrefPath(org, app); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasAltiVecRaw() => T.HasAltiVecRaw(); + public uint GetPrimaryDisplay() => T.GetPrimaryDisplay(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasArmsimd() => T.HasArmsimd(); + public Ptr GetPrimarySelectionText() => T.GetPrimarySelectionText(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasArmsimdRaw() => T.HasArmsimdRaw(); + public sbyte* GetPrimarySelectionTextRaw() => T.GetPrimarySelectionTextRaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasAVX() => T.HasAVX(); + public IOStreamHandle GetProcessInput(ProcessHandle process) => T.GetProcessInput(process); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessOutput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasAVX2() => T.HasAVX2(); + public IOStreamHandle GetProcessOutput(ProcessHandle process) => + T.GetProcessOutput(process); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasAVX2Raw() => T.HasAVX2Raw(); + public uint GetProcessProperties(ProcessHandle process) => T.GetProcessProperties(process); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasAVX512F() => T.HasAVX512F(); + public PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => T.GetPropertyType(props, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasAVX512FRaw() => T.HasAVX512FRaw(); + public PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => T.GetPropertyType(props, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasAVXRaw() => T.HasAVXRaw(); + public GamepadType GetRealGamepadType(GamepadHandle gamepad) => + T.GetRealGamepadType(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => - T.HasClipboardData(mime_type); + public GamepadType GetRealGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.GetRealGamepadTypeForID(instance_id); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasClipboardData( - [NativeTypeName("const char *")] Ref mime_type - ) => T.HasClipboardData(mime_type); + public byte GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int* X1, + int* Y1, + int* X2, + int* Y2 + ) => T.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasClipboardText() => T.HasClipboardText(); + public MaybeBool GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) => T.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasClipboardTextRaw() => T.HasClipboardTextRaw(); + public byte GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* rect, + float* X1, + float* Y1, + float* X2, + float* Y2 + ) => T.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => T.HasEvent(type); + public MaybeBool GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) => T.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasEventRaw([NativeTypeName("Uint32")] uint type) => T.HasEventRaw(type); + public byte GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Point* points, + int count, + [NativeTypeName("const SDL_Rect *")] Rect* clip, + Rect* result + ) => T.GetRectEnclosingPoints(points, count, clip, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => T.HasEvents(minType, maxType); + public MaybeBool GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Ref points, + int count, + [NativeTypeName("const SDL_Rect *")] Ref clip, + Ref result + ) => T.GetRectEnclosingPoints(points, count, clip, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasEventsRaw( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => T.HasEventsRaw(minType, maxType); + public byte GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count, + [NativeTypeName("const SDL_FRect *")] FRect* clip, + FRect* result + ) => T.GetRectEnclosingPointsFloat(points, count, clip, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasGamepad() => T.HasGamepad(); + public MaybeBool GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count, + [NativeTypeName("const SDL_FRect *")] Ref clip, + Ref result + ) => T.GetRectEnclosingPointsFloat(points, count, clip, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasGamepadRaw() => T.HasGamepadRaw(); + public byte GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => T.GetRectIntersection(A, B, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasJoystick() => T.HasJoystick(); + public MaybeBool GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) => T.GetRectIntersection(A, B, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasJoystickRaw() => T.HasJoystickRaw(); + public byte GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => T.GetRectIntersectionFloat(A, B, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasKeyboard() => T.HasKeyboard(); + public MaybeBool GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) => T.GetRectIntersectionFloat(A, B, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasKeyboardRaw() => T.HasKeyboardRaw(); + public byte GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => T.GetRectUnion(A, B, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasLasx() => T.HasLasx(); + public MaybeBool GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) => T.GetRectUnion(A, B, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasLasxRaw() => T.HasLasxRaw(); + public byte GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => T.GetRectUnionFloat(A, B, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasLSX() => T.HasLSX(); + public MaybeBool GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) => T.GetRectUnionFloat(A, B, result); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasLSXRaw() => T.HasLSXRaw(); + public uint GetRelativeMouseState(float* x, float* y) => T.GetRelativeMouseState(x, y); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasMMX() => T.HasMMX(); + public uint GetRelativeMouseState(Ref x, Ref y) => + T.GetRelativeMouseState(x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasMMXRaw() => T.HasMMXRaw(); + public byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => + T.GetRenderClipRect(renderer, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasMouse() => T.HasMouse(); + public MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) => + T.GetRenderClipRect(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasMouseRaw() => T.HasMouseRaw(); + public byte GetRenderColorScale(RendererHandle renderer, float* scale) => + T.GetRenderColorScale(renderer, scale); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasNeon() => T.HasNeon(); + public MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) => + T.GetRenderColorScale(renderer, scale); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasNeonRaw() => T.HasNeonRaw(); + public byte GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => T.GetRenderDrawBlendMode(renderer, blendMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool HasPrimarySelectionText() => T.HasPrimarySelectionText(); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasPrimarySelectionTextRaw() => T.HasPrimarySelectionTextRaw(); + public MaybeBool GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => T.GetRenderDrawBlendMode(renderer, blendMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => T.HasProperty(props, name); + public byte GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => T.GetRenderDrawColor(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) => T.HasProperty(props, name); + public MaybeBool GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => T.GetRenderDrawColor(renderer, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B - ) => T.HasRectIntersection(A, B); + public byte GetRenderDrawColorFloat( + RendererHandle renderer, + float* r, + float* g, + float* b, + float* a + ) => T.GetRenderDrawColorFloat(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B - ) => T.HasRectIntersection(A, B); + public MaybeBool GetRenderDrawColorFloat( + RendererHandle renderer, + Ref r, + Ref g, + Ref b, + Ref a + ) => T.GetRenderDrawColorFloat(renderer, r, g, b, a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B - ) => T.HasRectIntersectionFloat(A, B); + public Ptr GetRenderDriver(int index) => T.GetRenderDriver(index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B - ) => T.HasRectIntersectionFloat(A, B); + public sbyte* GetRenderDriverRaw(int index) => T.GetRenderDriverRaw(index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasScreenKeyboardSupport() => T.HasScreenKeyboardSupport(); + public RendererHandle GetRenderer(WindowHandle window) => T.GetRenderer(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasScreenKeyboardSupportRaw() => T.HasScreenKeyboardSupportRaw(); + public RendererHandle GetRendererFromTexture(Texture* texture) => + T.GetRendererFromTexture(texture); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasSSE() => T.HasSSE(); + public RendererHandle GetRendererFromTexture(Ref texture) => + T.GetRendererFromTexture(texture); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasSSE2() => T.HasSSE2(); + public Ptr GetRendererName(RendererHandle renderer) => T.GetRendererName(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasSSE2Raw() => T.HasSSE2Raw(); + public sbyte* GetRendererNameRaw(RendererHandle renderer) => T.GetRendererNameRaw(renderer); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasSSE3() => T.HasSSE3(); + public uint GetRendererProperties(RendererHandle renderer) => + T.GetRendererProperties(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasSSE3Raw() => T.HasSSE3Raw(); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool HasSSE41() => T.HasSSE41(); + public byte GetRenderLogicalPresentation( + RendererHandle renderer, + int* w, + int* h, + RendererLogicalPresentation* mode + ) => T.GetRenderLogicalPresentation(renderer, w, h, mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasSSE41Raw() => T.HasSSE41Raw(); + public MaybeBool GetRenderLogicalPresentation( + RendererHandle renderer, + Ref w, + Ref h, + Ref mode + ) => T.GetRenderLogicalPresentation(renderer, w, h, mode); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HasSSE42() => T.HasSSE42(); + public byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => + T.GetRenderLogicalPresentationRect(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasSSE42Raw() => T.HasSSE42Raw(); + public MaybeBool GetRenderLogicalPresentationRect( + RendererHandle renderer, + Ref rect + ) => T.GetRenderLogicalPresentationRect(renderer, rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HasSSERaw() => T.HasSSERaw(); + public Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => + T.GetRenderMetalCommandEncoder(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void HidBleScan([NativeTypeName("bool")] byte active) => T.HidBleScan(active); + public void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => + T.GetRenderMetalCommandEncoderRaw(renderer); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void HidBleScan([NativeTypeName("bool")] MaybeBool active) => - T.HidBleScan(active); + public Ptr GetRenderMetalLayer(RendererHandle renderer) => T.GetRenderMetalLayer(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidClose(HidDeviceHandle dev) => T.HidClose(dev); + public void* GetRenderMetalLayerRaw(RendererHandle renderer) => + T.GetRenderMetalLayerRaw(renderer); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint HidDeviceChangeCount() => T.HidDeviceChangeCount(); + public byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => + T.GetRenderOutputSize(renderer, w, h); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr HidEnumerate( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => T.HidEnumerate(vendor_id, product_id); + public MaybeBool GetRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h + ) => T.GetRenderOutputSize(renderer, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceInfo* HidEnumerateRaw( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => T.HidEnumerateRaw(vendor_id, product_id); + public byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => + T.GetRenderSafeArea(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidExit() => T.HidExit(); + public MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) => + T.GetRenderSafeArea(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void HidFreeEnumeration(HidDeviceInfo* devs) => T.HidFreeEnumeration(devs); + public byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => + T.GetRenderScale(renderer, scaleX, scaleY); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void HidFreeEnumeration(Ref devs) => T.HidFreeEnumeration(devs); + public MaybeBool GetRenderScale( + RendererHandle renderer, + Ref scaleX, + Ref scaleY + ) => T.GetRenderScale(renderer, scaleX, scaleY); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr HidGetDeviceInfo(HidDeviceHandle dev) => T.HidGetDeviceInfo(dev); + public Ptr GetRenderTarget(RendererHandle renderer) => T.GetRenderTarget(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => - T.HidGetDeviceInfoRaw(dev); + public Texture* GetRenderTargetRaw(RendererHandle renderer) => + T.GetRenderTargetRaw(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => T.HidGetFeatureReport(dev, data, length); + public byte GetRenderViewport(RendererHandle renderer, Rect* rect) => + T.GetRenderViewport(renderer, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => T.HidGetFeatureReport(dev, data, length); + public MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) => + T.GetRenderViewport(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetIndexedString(dev, string_index, @string, maxlen); + public byte GetRenderVSync(RendererHandle renderer, int* vsync) => + T.GetRenderVSync(renderer, vsync); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetIndexedString(dev, string_index, @string, maxlen); + public MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) => + T.GetRenderVSync(renderer, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => T.HidGetInputReport(dev, data, length); + public WindowHandle GetRenderWindow(RendererHandle renderer) => T.GetRenderWindow(renderer); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => T.HidGetInputReport(dev, data, length); + public Ptr GetRevision() => T.GetRevision(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetManufacturerString(dev, @string, maxlen); + public sbyte* GetRevisionRaw() => T.GetRevisionRaw(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetManufacturerString(dev, @string, maxlen); + public void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => T.GetRGB(pixel, format, palette, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetProductString(dev, @string, maxlen); + public void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => T.GetRGB(pixel, format, palette, r, g, b); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetProductString(dev, @string, maxlen); + public void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => T.GetRgba(pixel, format, palette, r, g, b, a); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* buf, - [NativeTypeName("size_t")] nuint buf_size - ) => T.HidGetReportDescriptor(dev, buf, buf_size); + public void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => T.GetRgba(pixel, format, palette, r, g, b, a); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref buf, - [NativeTypeName("size_t")] nuint buf_size - ) => T.HidGetReportDescriptor(dev, buf, buf_size); + public Sandbox GetSandbox() => T.GetSandbox(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetSerialNumberString(dev, @string, maxlen); + public Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] ushort* modstate + ) => T.GetScancodeFromKey(key, modstate); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => T.HidGetSerialNumberString(dev, @string, maxlen); + public Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] Ref modstate + ) => T.GetScancodeFromKey(key, modstate); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidInit() => T.HidInit(); + public Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => + T.GetScancodeFromName(name); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] uint* serial_number - ) => T.HidOpen(vendor_id, product_id, serial_number); + public Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) => + T.GetScancodeFromName(name); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] Ref serial_number - ) => T.HidOpen(vendor_id, product_id, serial_number); + public Ptr GetScancodeName(Scancode scancode) => T.GetScancodeName(scancode); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => - T.HidOpenPath(path); + public sbyte* GetScancodeNameRaw(Scancode scancode) => T.GetScancodeNameRaw(scancode); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) => - T.HidOpenPath(path); + public uint GetSemaphoreValue(SemaphoreHandle sem) => T.GetSemaphoreValue(sem); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => T.HidRead(dev, data, length); + public byte GetSensorData(SensorHandle sensor, float* data, int num_values) => + T.GetSensorData(sensor, data, num_values); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => T.HidRead(dev, data, length); + public MaybeBool GetSensorData( + SensorHandle sensor, + Ref data, + int num_values + ) => T.GetSensorData(sensor, data, num_values); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) => T.HidReadTimeout(dev, data, length, milliseconds); + public SensorHandle GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => + T.GetSensorFromID(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [return: NativeTypeName("SDL_SensorID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) => T.HidReadTimeout(dev, data, length, milliseconds); + public uint GetSensorID(SensorHandle sensor) => T.GetSensorID(sensor); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => T.HidSendFeatureReport(dev, data, length); + public Ptr GetSensorName(SensorHandle sensor) => T.GetSensorName(sensor); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => T.HidSendFeatureReport(dev, data, length); + public Ptr GetSensorNameForID([NativeTypeName("SDL_SensorID")] uint instance_id) => + T.GetSensorNameForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => - T.HidSetNonblocking(dev, nonblock); + public sbyte* GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => + T.GetSensorNameForIDRaw(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => T.HidWrite(dev, data, length); + public sbyte* GetSensorNameRaw(SensorHandle sensor) => T.GetSensorNameRaw(sensor); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => T.HidWrite(dev, data, length); + public int GetSensorNonPortableType(SensorHandle sensor) => + T.GetSensorNonPortableType(sensor); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HideCursor() => T.HideCursor(); + public int GetSensorNonPortableTypeForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => T.GetSensorNonPortableTypeForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HideCursorRaw() => T.HideCursorRaw(); + public uint GetSensorProperties(SensorHandle sensor) => T.GetSensorProperties(sensor); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_SensorID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public uint* GetSensors(int* count) => T.GetSensors(count); + + [return: NativeTypeName("SDL_SensorID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool HideWindow(WindowHandle window) => T.HideWindow(window); + public Ptr GetSensors(Ref count) => T.GetSensors(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte HideWindowRaw(WindowHandle window) => T.HideWindowRaw(window); + public SensorType GetSensorType(SensorHandle sensor) => T.GetSensorType(sensor); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => T.Init(flags); + public SensorType GetSensorTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => + T.GetSensorTypeForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool InitHapticRumble(HapticHandle haptic) => T.InitHapticRumble(haptic); + public int GetSilenceValueForFormat(AudioFormat format) => + T.GetSilenceValueForFormat(format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte InitHapticRumbleRaw(HapticHandle haptic) => T.InitHapticRumbleRaw(haptic); + public nuint GetSimdAlignment() => T.GetSimdAlignment(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => T.InitRaw(flags); + public byte GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("Uint64 *")] ulong* length + ) => T.GetStorageFileSize(storage, path, length); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - T.InitSubSystem(flags); + public MaybeBool GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("Uint64 *")] Ref length + ) => T.GetStorageFileSize(storage, path, length); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => - T.InitSubSystemRaw(flags); + public byte GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + PathInfo* info + ) => T.GetStoragePathInfo(storage, path, info); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] void* mem, - [NativeTypeName("size_t")] nuint size - ) => T.IOFromConstMem(mem, size); + public MaybeBool GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref info + ) => T.GetStoragePathInfo(storage, path, info); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] Ref mem, - [NativeTypeName("size_t")] nuint size - ) => T.IOFromConstMem(mem, size); + public ulong GetStorageSpaceRemaining(StorageHandle storage) => + T.GetStorageSpaceRemaining(storage); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromDynamicMem() => T.IOFromDynamicMem(); + public sbyte* GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* default_value + ) => T.GetStringProperty(props, name, default_value); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("const char *")] sbyte* mode - ) => T.IOFromFile(file, mode); + public Ptr GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref default_value + ) => T.GetStringProperty(props, name, default_value); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("const char *")] Ref mode - ) => T.IOFromFile(file, mode); + public byte GetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8 *")] byte* alpha) => + T.GetSurfaceAlphaMod(surface, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => - T.IOFromMem(mem, size); + public MaybeBool GetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref alpha + ) => T.GetSurfaceAlphaMod(surface, alpha); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) => - T.IOFromMem(mem, size); + public byte GetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => T.GetSurfaceBlendMode(surface, blendMode); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => T.IOvprintf(context, fmt, ap); + public MaybeBool GetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => T.GetSurfaceBlendMode(surface, blendMode); - [return: NativeTypeName("size_t")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => T.IOvprintf(context, fmt, ap); + public byte GetSurfaceClipRect(Surface* surface, Rect* rect) => + T.GetSurfaceClipRect(surface, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.IsGamepad(instance_id); + public MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) => + T.GetSurfaceClipRect(surface, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.IsGamepadRaw(instance_id); + public byte GetSurfaceColorKey(Surface* surface, [NativeTypeName("Uint32 *")] uint* key) => + T.GetSurfaceColorKey(surface, key); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsJoystickHaptic(JoystickHandle joystick) => - T.IsJoystickHaptic(joystick); + public MaybeBool GetSurfaceColorKey( + Ref surface, + [NativeTypeName("Uint32 *")] Ref key + ) => T.GetSurfaceColorKey(surface, key); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsJoystickHapticRaw(JoystickHandle joystick) => T.IsJoystickHapticRaw(joystick); + public byte GetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => T.GetSurfaceColorMod(surface, r, g, b); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsJoystickVirtual( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => T.IsJoystickVirtual(instance_id); + public MaybeBool GetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => T.GetSurfaceColorMod(surface, r, g, b); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.IsJoystickVirtualRaw(instance_id); + public Colorspace GetSurfaceColorspace(Surface* surface) => T.GetSurfaceColorspace(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsMouseHaptic() => T.IsMouseHaptic(); + public Colorspace GetSurfaceColorspace(Ref surface) => + T.GetSurfaceColorspace(surface); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsMouseHapticRaw() => T.IsMouseHapticRaw(); + public Surface** GetSurfaceImages(Surface* surface, int* count) => + T.GetSurfaceImages(surface, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsTablet() => T.IsTablet(); + public Ptr2D GetSurfaceImages(Ref surface, Ref count) => + T.GetSurfaceImages(surface, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsTabletRaw() => T.IsTabletRaw(); + public Palette* GetSurfacePalette(Surface* surface) => T.GetSurfacePalette(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool IsTV() => T.IsTV(); + public Ptr GetSurfacePalette(Ref surface) => T.GetSurfacePalette(surface); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte IsTVRaw() => T.IsTVRaw(); + public uint GetSurfaceProperties(Surface* surface) => T.GetSurfaceProperties(surface); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_PropertiesID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool JoystickConnected(JoystickHandle joystick) => - T.JoystickConnected(joystick); + public uint GetSurfaceProperties(Ref surface) => T.GetSurfaceProperties(surface); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte JoystickConnectedRaw(JoystickHandle joystick) => - T.JoystickConnectedRaw(joystick); + public int GetSystemRAM() => T.GetSystemRAM(); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public SystemTheme GetSystemTheme() => T.GetSystemTheme(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool JoystickEventsEnabled() => T.JoystickEventsEnabled(); + public byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => + T.GetTextInputArea(window, rect, cursor); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte JoystickEventsEnabledRaw() => T.JoystickEventsEnabledRaw(); + public MaybeBool GetTextInputArea( + WindowHandle window, + Ref rect, + Ref cursor + ) => T.GetTextInputArea(window, rect, cursor); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => T.LoadBMP(file); + public byte GetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8 *")] byte* alpha) => + T.GetTextureAlphaMod(texture, alpha); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr LoadBMP([NativeTypeName("const char *")] Ref file) => - T.LoadBMP(file); + public MaybeBool GetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref alpha + ) => T.GetTextureAlphaMod(texture, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => - T.LoadBMPIO(src, closeio); + public byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => + T.GetTextureAlphaModFloat(texture, alpha); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr LoadBMPIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => T.LoadBMPIO(src, closeio); + public MaybeBool GetTextureAlphaModFloat(Ref texture, Ref alpha) => + T.GetTextureAlphaModFloat(texture, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* LoadFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("size_t *")] nuint* datasize - ) => T.LoadFile(file, datasize); + public byte GetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => T.GetTextureBlendMode(texture, blendMode); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr LoadFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("size_t *")] Ref datasize - ) => T.LoadFile(file, datasize); + public MaybeBool GetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => T.GetTextureBlendMode(texture, blendMode); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] nuint* datasize, - [NativeTypeName("bool")] byte closeio - ) => T.LoadFileIO(src, datasize, closeio); + public byte GetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => T.GetTextureColorMod(texture, r, g, b); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] Ref datasize, - [NativeTypeName("bool")] MaybeBool closeio - ) => T.LoadFileIO(src, datasize, closeio); + public MaybeBool GetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => T.GetTextureColorMod(texture, r, g, b); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] sbyte* name - ) => T.LoadFunction(handle, name); + public byte GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => + T.GetTextureColorModFloat(texture, r, g, b); - [return: NativeTypeName("SDL_FunctionPointer")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] Ref name - ) => T.LoadFunction(handle, name); + public MaybeBool GetTextureColorModFloat( + Ref texture, + Ref r, + Ref g, + Ref b + ) => T.GetTextureColorModFloat(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SharedObjectHandle LoadObject([NativeTypeName("const char *")] sbyte* sofile) => - T.LoadObject(sofile); + public uint GetTextureProperties(Texture* texture) => T.GetTextureProperties(texture); + [return: NativeTypeName("SDL_PropertiesID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SharedObjectHandle LoadObject([NativeTypeName("const char *")] Ref sofile) => - T.LoadObject(sofile); + public uint GetTextureProperties(Ref texture) => T.GetTextureProperties(texture); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LoadWAV( - [NativeTypeName("const char *")] sbyte* path, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => T.LoadWAV(path, spec, audio_buf, audio_len); + public byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => + T.GetTextureScaleMode(texture, scaleMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LoadWAV( - [NativeTypeName("const char *")] Ref path, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) => T.LoadWAV(path, spec, audio_buf, audio_len); + public MaybeBool GetTextureScaleMode( + Ref texture, + Ref scaleMode + ) => T.GetTextureScaleMode(texture, scaleMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => T.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); + public byte GetTextureSize(Texture* texture, float* w, float* h) => + T.GetTextureSize(texture, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) => T.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); + public MaybeBool GetTextureSize(Ref texture, Ref w, Ref h) => + T.GetTextureSize(texture, w, h); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LockAudioStream(AudioStreamHandle stream) => - T.LockAudioStream(stream); + public ulong GetThreadID(ThreadHandle thread) => T.GetThreadID(thread); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LockAudioStreamRaw(AudioStreamHandle stream) => T.LockAudioStreamRaw(stream); + public Ptr GetThreadName(ThreadHandle thread) => T.GetThreadName(thread); - [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockJoysticks() => T.LockJoysticks(); + public sbyte* GetThreadNameRaw(ThreadHandle thread) => T.GetThreadNameRaw(thread); - [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockMutex(MutexHandle mutex) => T.LockMutex(mutex); + public ulong GetTicks() => T.GetTicks(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - T.LockProperties(props); + public ulong GetTicksNS() => T.GetTicksNS(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => - T.LockPropertiesRaw(props); + public void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => T.GetTLS(id); - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockRWLockForReading(RWLockHandle rwlock) => T.LockRWLockForReading(rwlock); + public Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) => T.GetTLS(id); - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockRWLockForWriting(RWLockHandle rwlock) => T.LockRWLockForWriting(rwlock); + public Ptr GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => + T.GetTouchDeviceName(touchID); - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - T.LockSpinlock(@lock); + public sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => + T.GetTouchDeviceNameRaw(touchID); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [return: NativeTypeName("SDL_TouchID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => - T.LockSpinlock(@lock); + public ulong* GetTouchDevices(int* count) => T.GetTouchDevices(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [return: NativeTypeName("SDL_TouchID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LockSurface(Surface* surface) => T.LockSurface(surface); + public Ptr GetTouchDevices(Ref count) => T.GetTouchDevices(count); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LockSurface(Ref surface) => T.LockSurface(surface); + public TouchDeviceType GetTouchDeviceType([NativeTypeName("SDL_TouchID")] ulong touchID) => + T.GetTouchDeviceType(touchID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LockTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - void** pixels, - int* pitch - ) => T.LockTexture(texture, rect, pixels, pitch); + public Finger** GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + int* count + ) => T.GetTouchFingers(touchID, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LockTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D pixels, - Ref pitch - ) => T.LockTexture(texture, rect, pixels, pitch); + public Ptr2D GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + Ref count + ) => T.GetTouchFingers(touchID, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte LockTextureToSurface( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - Surface** surface - ) => T.LockTextureToSurface(texture, rect, surface); + public Ptr GetUserFolder(Folder folder) => T.GetUserFolder(folder); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool LockTextureToSurface( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D surface - ) => T.LockTextureToSurface(texture, rect, surface); + public sbyte* GetUserFolderRaw(Folder folder) => T.GetUserFolderRaw(folder); - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => T.LogMessageV(category, priority, fmt, ap); + public int GetVersion() => T.GetVersion(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => T.LogMessageV(category, priority, fmt, ap); + public Ptr GetVideoDriver(int index) => T.GetVideoDriver(index); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.MapRGB(format, palette, r, g, b); + public sbyte* GetVideoDriverRaw(int index) => T.GetVideoDriverRaw(index); - [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] - [MethodImpl( + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.MapRGB(format, palette, r, g, b); + public byte GetWindowAspectRatio( + WindowHandle window, + float* min_aspect, + float* max_aspect + ) => T.GetWindowAspectRatio(window, min_aspect, max_aspect); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.MapRgba(format, palette, r, g, b, a); + public MaybeBool GetWindowAspectRatio( + WindowHandle window, + Ref min_aspect, + Ref max_aspect + ) => T.GetWindowAspectRatio(window, min_aspect, max_aspect); - [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.MapRgba(format, palette, r, g, b, a); + public byte GetWindowBordersSize( + WindowHandle window, + int* top, + int* left, + int* bottom, + int* right + ) => T.GetWindowBordersSize(window, top, left, bottom, right); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapSurfaceRGB( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.MapSurfaceRGB(surface, r, g, b); + public MaybeBool GetWindowBordersSize( + WindowHandle window, + Ref top, + Ref left, + Ref bottom, + Ref right + ) => T.GetWindowBordersSize(window, top, left, bottom, right); - [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapSurfaceRGB( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.MapSurfaceRGB(surface, r, g, b); + public float GetWindowDisplayScale(WindowHandle window) => T.GetWindowDisplayScale(window); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [return: NativeTypeName("SDL_WindowFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapSurfaceRgba( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.MapSurfaceRgba(surface, r, g, b, a); + public ulong GetWindowFlags(WindowHandle window) => T.GetWindowFlags(window); - [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint MapSurfaceRgba( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.MapSurfaceRgba(surface, r, g, b, a); + public WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Event* @event + ) => T.GetWindowFromEvent(@event); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool MaximizeWindow(WindowHandle window) => T.MaximizeWindow(window); + public WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Ref @event + ) => T.GetWindowFromEvent(@event); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte MaximizeWindowRaw(WindowHandle window) => T.MaximizeWindowRaw(window); + public WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => + T.GetWindowFromID(id); - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void MemoryBarrierAcquireFunction() => T.MemoryBarrierAcquireFunction(); + public Ptr GetWindowFullscreenMode(WindowHandle window) => + T.GetWindowFullscreenMode(window); - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void MemoryBarrierReleaseFunction() => T.MemoryBarrierReleaseFunction(); + public DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => + T.GetWindowFullscreenModeRaw(window); - [return: NativeTypeName("SDL_MetalView")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr MetalCreateView(WindowHandle window) => T.MetalCreateView(window); + public void* GetWindowICCProfile( + WindowHandle window, + [NativeTypeName("size_t *")] nuint* size + ) => T.GetWindowICCProfile(window, size); - [return: NativeTypeName("SDL_MetalView")] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* MetalCreateViewRaw(WindowHandle window) => T.MetalCreateViewRaw(window); + public Ptr GetWindowICCProfile( + WindowHandle window, + [NativeTypeName("size_t *")] Ref size + ) => T.GetWindowICCProfile(window, size); - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [return: NativeTypeName("SDL_WindowID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => - T.MetalDestroyView(view); + public uint GetWindowID(WindowHandle window) => T.GetWindowID(window); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) => - T.MetalDestroyView(view); + public MaybeBool GetWindowKeyboardGrab(WindowHandle window) => + T.GetWindowKeyboardGrab(window); - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => - T.MetalGetLayer(view); + public byte GetWindowKeyboardGrabRaw(WindowHandle window) => + T.GetWindowKeyboardGrabRaw(window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) => - T.MetalGetLayer(view); + public byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => + T.GetWindowMaximumSize(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool MinimizeWindow(WindowHandle window) => T.MinimizeWindow(window); + public MaybeBool GetWindowMaximumSize(WindowHandle window, Ref w, Ref h) => + T.GetWindowMaximumSize(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte MinimizeWindowRaw(WindowHandle window) => T.MinimizeWindowRaw(window); + public byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => + T.GetWindowMinimumSize(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte MixAudio( - [NativeTypeName("Uint8 *")] byte* dst, - [NativeTypeName("const Uint8 *")] byte* src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume - ) => T.MixAudio(dst, src, format, len, volume); + public MaybeBool GetWindowMinimumSize(WindowHandle window, Ref w, Ref h) => + T.GetWindowMinimumSize(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool MixAudio( - [NativeTypeName("Uint8 *")] Ref dst, - [NativeTypeName("const Uint8 *")] Ref src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume - ) => T.MixAudio(dst, src, format, len, volume); + public MaybeBool GetWindowMouseGrab(WindowHandle window) => + T.GetWindowMouseGrab(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationDidEnterBackground() => T.OnApplicationDidEnterBackground(); + public byte GetWindowMouseGrabRaw(WindowHandle window) => T.GetWindowMouseGrabRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] + [return: NativeTypeName("const SDL_Rect *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationDidEnterForeground() => T.OnApplicationDidEnterForeground(); + public Ptr GetWindowMouseRect(WindowHandle window) => T.GetWindowMouseRect(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] + [return: NativeTypeName("const SDL_Rect *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationDidReceiveMemoryWarning() => - T.OnApplicationDidReceiveMemoryWarning(); + public Rect* GetWindowMouseRectRaw(WindowHandle window) => T.GetWindowMouseRectRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationWillEnterBackground() => T.OnApplicationWillEnterBackground(); + public float GetWindowOpacity(WindowHandle window) => T.GetWindowOpacity(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationWillEnterForeground() => T.OnApplicationWillEnterForeground(); + public WindowHandle GetWindowParent(WindowHandle window) => T.GetWindowParent(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void OnApplicationWillTerminate() => T.OnApplicationWillTerminate(); + public float GetWindowPixelDensity(WindowHandle window) => T.GetWindowPixelDensity(window); - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec - ) => T.OpenAudioDevice(devid, spec); + public PixelFormat GetWindowPixelFormat(WindowHandle window) => + T.GetWindowPixelFormat(window); - [return: NativeTypeName("SDL_AudioDeviceID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec - ) => T.OpenAudioDevice(devid, spec); + public byte GetWindowPosition(WindowHandle window, int* x, int* y) => + T.GetWindowPosition(window, x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => T.OpenAudioDeviceStream(devid, spec, callback, userdata); + public MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) => + T.GetWindowPosition(window, x, y); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) => T.OpenAudioDeviceStream(devid, spec, callback, userdata); + public uint GetWindowProperties(WindowHandle window) => T.GetWindowProperties(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec - ) => T.OpenCamera(instance_id, spec); + public MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => + T.GetWindowRelativeMouseMode(window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] Ref spec - ) => T.OpenCamera(instance_id, spec); + public byte GetWindowRelativeMouseModeRaw(WindowHandle window) => + T.GetWindowRelativeMouseModeRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => - T.OpenFileStorage(path); + public WindowHandle* GetWindows(int* count) => T.GetWindows(count); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenFileStorage([NativeTypeName("const char *")] Ref path) => - T.OpenFileStorage(path); + public Ptr GetWindows(Ref count) => T.GetWindows(count); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public GamepadHandle OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.OpenGamepad(instance_id); + public byte GetWindowSafeArea(WindowHandle window, Rect* rect) => + T.GetWindowSafeArea(window, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => - T.OpenHaptic(instance_id); + public MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) => + T.GetWindowSafeArea(window, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => - T.OpenHapticFromJoystick(joystick); + public byte GetWindowSize(WindowHandle window, int* w, int* h) => + T.GetWindowSize(window, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public HapticHandle OpenHapticFromMouse() => T.OpenHapticFromMouse(); + public MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) => + T.GetWindowSize(window, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, - void* userdata - ) => T.OpenIO(iface, userdata); + public byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => + T.GetWindowSizeInPixels(window, w, h); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, - Ref userdata - ) => T.OpenIO(iface, userdata); + public MaybeBool GetWindowSizeInPixels(WindowHandle window, Ref w, Ref h) => + T.GetWindowSizeInPixels(window, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public JoystickHandle OpenJoystick([NativeTypeName("SDL_JoystickID")] uint instance_id) => - T.OpenJoystick(instance_id); + public Ptr GetWindowSurface(WindowHandle window) => T.GetWindowSurface(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => - T.OpenSensor(instance_id); + public Surface* GetWindowSurfaceRaw(WindowHandle window) => T.GetWindowSurfaceRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, - void* userdata - ) => T.OpenStorage(iface, userdata); + public byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => + T.GetWindowSurfaceVSync(window, vsync); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] Ref iface, - Ref userdata - ) => T.OpenStorage(iface, userdata); + public MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) => + T.GetWindowSurfaceVSync(window, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] sbyte* @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.OpenTitleStorage(@override, props); + public Ptr GetWindowTitle(WindowHandle window) => T.GetWindowTitle(window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] Ref @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.OpenTitleStorage(@override, props); + public sbyte* GetWindowTitleRaw(WindowHandle window) => T.GetWindowTitleRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte OpenURL([NativeTypeName("const char *")] sbyte* url) => T.OpenURL(url); + public GLContextStateHandle GLCreateContext(WindowHandle window) => + T.GLCreateContext(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) => - T.OpenURL(url); + public MaybeBool GLDestroyContext( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => T.GLDestroyContext(context); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.OpenUserStorage(org, app, props); + public byte GLDestroyContextRaw( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => T.GLDestroyContextRaw(context); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.OpenUserStorage(org, app, props); + public byte GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => + T.GLExtensionSupported(extension); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool OutOfMemory() => T.OutOfMemory(); + public MaybeBool GLExtensionSupported( + [NativeTypeName("const char *")] Ref extension + ) => T.GLExtensionSupported(extension); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte OutOfMemoryRaw() => T.OutOfMemoryRaw(); + public byte GLGetAttribute(GLAttr attr, int* value) => T.GLGetAttribute(attr, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PauseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.PauseAudioDevice(dev); + public MaybeBool GLGetAttribute(GLAttr attr, Ref value) => + T.GLGetAttribute(attr, value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.PauseAudioDeviceRaw(dev); + public GLContextStateHandle GLGetCurrentContext() => T.GLGetCurrentContext(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => - T.PauseAudioStreamDevice(stream); + public WindowHandle GLGetCurrentWindow() => T.GLGetCurrentWindow(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => - T.PauseAudioStreamDeviceRaw(stream); + public FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + T.GLGetProcAddress(proc); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PauseHaptic(HapticHandle haptic) => T.PauseHaptic(haptic); + public FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] Ref proc) => + T.GLGetProcAddress(proc); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PauseHapticRaw(HapticHandle haptic) => T.PauseHapticRaw(haptic); + public byte GLGetSwapInterval(int* interval) => T.GLGetSwapInterval(interval); - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int PeepEvents( - Event* events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => T.PeepEvents(events, numevents, action, minType, maxType); + public MaybeBool GLGetSwapInterval(Ref interval) => + T.GLGetSwapInterval(interval); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int PeepEvents( - Ref events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => T.PeepEvents(events, numevents, action, minType, maxType); + public byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + T.GLLoadLibrary(path); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PlayHapticRumble( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => T.PlayHapticRumble(haptic, strength, length); + public MaybeBool GLLoadLibrary([NativeTypeName("const char *")] Ref path) => + T.GLLoadLibrary(path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PlayHapticRumbleRaw( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => T.PlayHapticRumbleRaw(haptic, strength, length); + public MaybeBool GLMakeCurrent( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => T.GLMakeCurrent(window, context); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PollEvent(Event* @event) => T.PollEvent(@event); + public byte GLMakeCurrentRaw( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => T.GLMakeCurrentRaw(window, context); + + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void GLResetAttributes() => T.GLResetAttributes(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PollEvent(Ref @event) => T.PollEvent(@event); + public MaybeBool GLSetAttribute(GLAttr attr, int value) => + T.GLSetAttribute(attr, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch, - [NativeTypeName("bool")] byte linear - ) => - T.PremultiplyAlpha( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch, - linear - ); + public byte GLSetAttributeRaw(GLAttr attr, int value) => T.GLSetAttributeRaw(attr, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch, - [NativeTypeName("bool")] MaybeBool linear - ) => - T.PremultiplyAlpha( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch, - linear - ); + public MaybeBool GLSetSwapInterval(int interval) => T.GLSetSwapInterval(interval); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PremultiplySurfaceAlpha( - Surface* surface, - [NativeTypeName("bool")] byte linear - ) => T.PremultiplySurfaceAlpha(surface, linear); + public byte GLSetSwapIntervalRaw(int interval) => T.GLSetSwapIntervalRaw(interval); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PremultiplySurfaceAlpha( - Ref surface, - [NativeTypeName("bool")] MaybeBool linear - ) => T.PremultiplySurfaceAlpha(surface, linear); + public MaybeBool GLSwapWindow(WindowHandle window) => T.GLSwapWindow(window); - [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void PumpEvents() => T.PumpEvents(); + public byte GLSwapWindowRaw(WindowHandle window) => T.GLSwapWindowRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PushEvent(Event* @event) => T.PushEvent(@event); + public void GLUnloadLibrary() => T.GLUnloadLibrary(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public sbyte** GlobDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => T.GlobDirectory(path, pattern, flags, count); + + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PushEvent(Ref @event) => T.PushEvent(@event); + public Ptr2D GlobDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) => T.GlobDirectory(path, pattern, flags, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] void* buf, - int len - ) => T.PutAudioStreamData(stream, buf, len); + public sbyte** GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => T.GlobStorageDirectory(storage, path, pattern, flags, count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] Ref buf, - int len - ) => T.PutAudioStreamData(stream, buf, len); + public Ptr2D GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) => T.GlobStorageDirectory(storage, path, pattern, flags, count); - [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void Quit() => T.Quit(); + public MaybeBool GPUSupportsProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.GPUSupportsProperties(props); - [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - T.QuitSubSystem(flags); + public byte GPUSupportsPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + T.GPUSupportsPropertiesRaw(props); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RaiseWindow(WindowHandle window) => T.RaiseWindow(window); + public byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ) => T.GPUSupportsShaderFormats(format_flags, name); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RaiseWindowRaw(WindowHandle window) => T.RaiseWindowRaw(window); + public MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ) => T.GPUSupportsShaderFormats(format_flags, name); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint ReadIO( - IOStreamHandle context, - void* ptr, - [NativeTypeName("size_t")] nuint size - ) => T.ReadIO(context, ptr, size); + public uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format) => + T.GPUTextureFormatTexelBlockSize(format); - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint ReadIO( - IOStreamHandle context, - Ref ptr, - [NativeTypeName("size_t")] nuint size - ) => T.ReadIO(context, ptr, size); + public MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => T.GPUTextureSupportsFormat(device, format, type, usage); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => - T.ReadS16BE(src, value); + public byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => T.GPUTextureSupportsFormatRaw(device, format, type, usage); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS16BE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value - ) => T.ReadS16BE(src, value); + public MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => T.GPUTextureSupportsSampleCount(device, format, sample_count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => - T.ReadS16LE(src, value); + public byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => T.GPUTextureSupportsSampleCountRaw(device, format, sample_count); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS16LE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value - ) => T.ReadS16LE(src, value); + public void GuidToString( + Guid guid, + [NativeTypeName("char *")] sbyte* pszGUID, + int cbGUID + ) => T.GuidToString(guid, pszGUID, cbGUID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - T.ReadS32BE(src, value); + public void GuidToString( + Guid guid, + [NativeTypeName("char *")] Ref pszGUID, + int cbGUID + ) => T.GuidToString(guid, pszGUID, cbGUID); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS32BE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) => T.ReadS32BE(src, value); + public byte HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => T.HapticEffectSupported(haptic, effect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - T.ReadS32LE(src, value); + public MaybeBool HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) => T.HapticEffectSupported(haptic, effect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS32LE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) => T.ReadS32LE(src, value); + public MaybeBool HapticRumbleSupported(HapticHandle haptic) => + T.HapticRumbleSupported(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => - T.ReadS64BE(src, value); + public byte HapticRumbleSupportedRaw(HapticHandle haptic) => + T.HapticRumbleSupportedRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS64BE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) => T.ReadS64BE(src, value); + public MaybeBool HasAltiVec() => T.HasAltiVec(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => - T.ReadS64LE(src, value); + public byte HasAltiVecRaw() => T.HasAltiVecRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS64LE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) => T.ReadS64LE(src, value); + public MaybeBool HasArmsimd() => T.HasArmsimd(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => - T.ReadS8(src, value); + public byte HasArmsimdRaw() => T.HasArmsimdRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadS8( - IOStreamHandle src, - [NativeTypeName("Sint8 *")] Ref value - ) => T.ReadS8(src, value); + public MaybeBool HasAVX() => T.HasAVX(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - void* destination, - [NativeTypeName("Uint64")] ulong length - ) => T.ReadStorageFile(storage, path, destination, length); + public MaybeBool HasAVX2() => T.HasAVX2(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref destination, - [NativeTypeName("Uint64")] ulong length - ) => T.ReadStorageFile(storage, path, destination, length); + public byte HasAVX2Raw() => T.HasAVX2Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => T.ReadSurfacePixel(surface, x, y, r, g, b, a); + public MaybeBool HasAVX512F() => T.HasAVX512F(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => T.ReadSurfacePixel(surface, x, y, r, g, b, a); + public byte HasAVX512FRaw() => T.HasAVX512FRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadSurfacePixelFloat( - Surface* surface, - int x, - int y, - float* r, - float* g, - float* b, - float* a - ) => T.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); + public byte HasAVXRaw() => T.HasAVXRaw(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadSurfacePixelFloat( - Ref surface, - int x, - int y, - Ref r, - Ref g, - Ref b, - Ref a - ) => T.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); + public byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => + T.HasClipboardData(mime_type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => - T.ReadU16BE(src, value); + public MaybeBool HasClipboardData( + [NativeTypeName("const char *")] Ref mime_type + ) => T.HasClipboardData(mime_type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU16BE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) => T.ReadU16BE(src, value); + public MaybeBool HasClipboardText() => T.HasClipboardText(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => - T.ReadU16LE(src, value); + public byte HasClipboardTextRaw() => T.HasClipboardTextRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU16LE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) => T.ReadU16LE(src, value); + public MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => T.HasEvent(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => - T.ReadU32BE(src, value); + public byte HasEventRaw([NativeTypeName("Uint32")] uint type) => T.HasEventRaw(type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU32BE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) => T.ReadU32BE(src, value); + public MaybeBool HasEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => T.HasEvents(minType, maxType); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => - T.ReadU32LE(src, value); + public byte HasEventsRaw( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => T.HasEventsRaw(minType, maxType); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU32LE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) => T.ReadU32LE(src, value); + public MaybeBool HasGamepad() => T.HasGamepad(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => - T.ReadU64BE(src, value); + public byte HasGamepadRaw() => T.HasGamepadRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU64BE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value - ) => T.ReadU64BE(src, value); + public MaybeBool HasJoystick() => T.HasJoystick(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => - T.ReadU64LE(src, value); + public byte HasJoystickRaw() => T.HasJoystickRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU64LE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value - ) => T.ReadU64LE(src, value); + public MaybeBool HasKeyboard() => T.HasKeyboard(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => - T.ReadU8(src, value); + public byte HasKeyboardRaw() => T.HasKeyboardRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReadU8( - IOStreamHandle src, - [NativeTypeName("Uint8 *")] Ref value - ) => T.ReadU8(src, value); + public MaybeBool HasLasx() => T.HasLasx(); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint RegisterEvents(int numevents) => T.RegisterEvents(numevents); + public byte HasLasxRaw() => T.HasLasxRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => - T.ReleaseCameraFrame(camera, frame); + public MaybeBool HasLSX() => T.HasLSX(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ReleaseCameraFrame(CameraHandle camera, Ref frame) => - T.ReleaseCameraFrame(camera, frame); + public byte HasLSXRaw() => T.HasLSXRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ReloadGamepadMappings() => T.ReloadGamepadMappings(); + public MaybeBool HasMMX() => T.HasMMX(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ReloadGamepadMappingsRaw() => T.ReloadGamepadMappingsRaw(); + public byte HasMMXRaw() => T.HasMMXRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => T.RemoveEventWatch(filter, userdata); + public MaybeBool HasMouse() => T.HasMouse(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => T.RemoveEventWatch(filter, userdata); - - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void RemoveHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => T.RemoveHintCallback(name, callback, userdata); + public byte HasMouseRaw() => T.HasMouseRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void RemoveHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) => T.RemoveHintCallback(name, callback, userdata); + public MaybeBool HasNeon() => T.HasNeon(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RemovePath([NativeTypeName("const char *")] sbyte* path) => T.RemovePath(path); + public byte HasNeonRaw() => T.HasNeonRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) => - T.RemovePath(path); + public MaybeBool HasPrimarySelectionText() => T.HasPrimarySelectionText(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => T.RemoveStoragePath(storage, path); + public byte HasPrimarySelectionTextRaw() => T.HasPrimarySelectionTextRaw(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) => T.RemoveStoragePath(storage, path); + public byte HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => T.HasProperty(props, name); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void RemoveSurfaceAlternateImages(Surface* surface) => - T.RemoveSurfaceAlternateImages(surface); + public MaybeBool HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => T.HasProperty(props, name); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void RemoveSurfaceAlternateImages(Ref surface) => - T.RemoveSurfaceAlternateImages(surface); + public byte HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B + ) => T.HasRectIntersection(A, B); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => - T.RemoveTimer(id); + public MaybeBool HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B + ) => T.HasRectIntersection(A, B); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => T.RemoveTimerRaw(id); + public byte HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B + ) => T.HasRectIntersectionFloat(A, B); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenamePath( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => T.RenamePath(oldpath, newpath); + public MaybeBool HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B + ) => T.HasRectIntersectionFloat(A, B); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenamePath( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => T.RenamePath(oldpath, newpath); + public MaybeBool HasScreenKeyboardSupport() => T.HasScreenKeyboardSupport(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => T.RenameStoragePath(storage, oldpath, newpath); + public byte HasScreenKeyboardSupportRaw() => T.HasScreenKeyboardSupportRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => T.RenameStoragePath(storage, oldpath, newpath); + public MaybeBool HasSSE() => T.HasSSE(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderClear(RendererHandle renderer) => T.RenderClear(renderer); + public MaybeBool HasSSE2() => T.HasSSE2(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderClearRaw(RendererHandle renderer) => T.RenderClearRaw(renderer); + public byte HasSSE2Raw() => T.HasSSE2Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderClipEnabled(RendererHandle renderer) => - T.RenderClipEnabled(renderer); + public MaybeBool HasSSE3() => T.HasSSE3(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderClipEnabledRaw(RendererHandle renderer) => - T.RenderClipEnabledRaw(renderer); + public byte HasSSE3Raw() => T.HasSSE3Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - float* x, - float* y - ) => T.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); + public MaybeBool HasSSE41() => T.HasSSE41(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - Ref x, - Ref y - ) => T.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); + public byte HasSSE41Raw() => T.HasSSE41Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - float* window_x, - float* window_y - ) => T.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + public MaybeBool HasSSE42() => T.HasSSE42(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - Ref window_x, - Ref window_y - ) => T.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + public byte HasSSE42Raw() => T.HasSSE42Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] sbyte* str - ) => T.RenderDebugText(renderer, x, y, str); + public byte HasSSERaw() => T.HasSSERaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] Ref str - ) => T.RenderDebugText(renderer, x, y, str); + public void HidBleScan([NativeTypeName("bool")] byte active) => T.HidBleScan(active); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => T.RenderFillRect(renderer, rect); + public void HidBleScan([NativeTypeName("bool")] MaybeBool active) => + T.HidBleScan(active); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect - ) => T.RenderFillRect(renderer, rect); + public int HidClose(HidDeviceHandle dev) => T.HidClose(dev); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => T.RenderFillRects(renderer, rects, count); + public uint HidDeviceChangeCount() => T.HidDeviceChangeCount(); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) => T.RenderFillRects(renderer, rects, count); + public Ptr HidEnumerate( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => T.HidEnumerate(vendor_id, product_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderGeometry( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, - int num_vertices, - [NativeTypeName("const int *")] int* indices, - int num_indices - ) => T.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); + public HidDeviceInfo* HidEnumerateRaw( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => T.HidEnumerateRaw(vendor_id, product_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderGeometry( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_Vertex *")] Ref vertices, - int num_vertices, - [NativeTypeName("const int *")] Ref indices, - int num_indices - ) => T.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); + public int HidExit() => T.HidExit(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderGeometryRaw( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const float *")] float* xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] FColor* color, - int color_stride, - [NativeTypeName("const float *")] float* uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] void* indices, - int num_indices, - int size_indices - ) => - T.RenderGeometryRaw( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); + public void HidFreeEnumeration(HidDeviceInfo* devs) => T.HidFreeEnumeration(devs); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderGeometryRaw( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const float *")] Ref xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] Ref color, - int color_stride, - [NativeTypeName("const float *")] Ref uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] Ref indices, - int num_indices, - int size_indices - ) => - T.RenderGeometryRaw( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); + public void HidFreeEnumeration(Ref devs) => T.HidFreeEnumeration(devs); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderLine( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => T.RenderLine(renderer, x1, y1, x2, y2); + public Ptr HidGetDeviceInfo(HidDeviceHandle dev) => T.HidGetDeviceInfo(dev); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderLineRaw( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => T.RenderLineRaw(renderer, x1, y1, x2, y2); + public HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => + T.HidGetDeviceInfoRaw(dev); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => T.RenderLines(renderer, points, count); + public int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => T.HidGetFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) => T.RenderLines(renderer, points, count); + public int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => T.HidGetFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => - T.RenderPoint(renderer, x, y); + public int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetIndexedString(dev, string_index, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderPointRaw(RendererHandle renderer, float x, float y) => - T.RenderPointRaw(renderer, x, y); + public int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetIndexedString(dev, string_index, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => T.RenderPoints(renderer, points, count); + public int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => T.HidGetInputReport(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) => T.RenderPoints(renderer, points, count); + public int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => T.HidGetInputReport(dev, data, length); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderPresent(RendererHandle renderer) => T.RenderPresent(renderer); + public int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetManufacturerString(dev, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderPresentRaw(RendererHandle renderer) => T.RenderPresentRaw(renderer); + public int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetManufacturerString(dev, @string, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => T.RenderReadPixels(renderer, rect); + public int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetProductString(dev, @string, maxlen); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => T.RenderReadPixels(renderer, rect); + public int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetProductString(dev, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => T.RenderRect(renderer, rect); + public int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* buf, + [NativeTypeName("size_t")] nuint buf_size + ) => T.HidGetReportDescriptor(dev, buf, buf_size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect - ) => T.RenderRect(renderer, rect); + public int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref buf, + [NativeTypeName("size_t")] nuint buf_size + ) => T.HidGetReportDescriptor(dev, buf, buf_size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => T.RenderRects(renderer, rects, count); - - [return: NativeTypeName("bool")] + public int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetSerialNumberString(dev, @string, maxlen); + [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) => T.RenderRects(renderer, rects, count); + public int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => T.HidGetSerialNumberString(dev, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderTexture( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => T.RenderTexture(renderer, texture, srcrect, dstrect); + public int HidInit() => T.HidInit(); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] uint* serial_number + ) => T.HidOpen(vendor_id, product_id, serial_number); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderTexture( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => T.RenderTexture(renderer, texture, srcrect, dstrect); + public HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] Ref serial_number + ) => T.HidOpen(vendor_id, product_id, serial_number); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderTexture9Grid( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => - T.RenderTexture9Grid( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); + public HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => + T.HidOpenPath(path); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderTexture9Grid( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => - T.RenderTexture9Grid( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); + public HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) => + T.HidOpenPath(path); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderTextureRotated( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] FPoint* center, - FlipMode flip - ) => T.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); + public int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => T.HidRead(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderTextureRotated( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] Ref center, - FlipMode flip - ) => T.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); + public int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => T.HidRead(dev, data, length); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderTextureTiled( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => T.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + public int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => T.HidReadTimeout(dev, data, length, milliseconds); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderTextureTiled( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => T.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + public int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => T.HidReadTimeout(dev, data, length, milliseconds); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => T.HidSendFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RenderViewportSet(RendererHandle renderer) => - T.RenderViewportSet(renderer); + public int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => T.HidSendFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RenderViewportSetRaw(RendererHandle renderer) => - T.RenderViewportSetRaw(renderer); + public int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => + T.HidSetNonblocking(dev, nonblock); - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertState ReportAssertion( - AssertData* data, - [NativeTypeName("const char *")] sbyte* func, - [NativeTypeName("const char *")] sbyte* file, - int line - ) => T.ReportAssertion(data, func, file, line); + public int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => T.HidWrite(dev, data, length); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public AssertState ReportAssertion( - Ref data, - [NativeTypeName("const char *")] Ref func, - [NativeTypeName("const char *")] Ref file, - int line - ) => T.ReportAssertion(data, func, file, line); + public int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => T.HidWrite(dev, data, length); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ResetAssertionReport() => T.ResetAssertionReport(); + public MaybeBool HideCursor() => T.HideCursor(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ResetHint([NativeTypeName("const char *")] sbyte* name) => T.ResetHint(name); + public byte HideCursorRaw() => T.HideCursorRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) => - T.ResetHint(name); + public MaybeBool HideWindow(WindowHandle window) => T.HideWindow(window); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ResetHints() => T.ResetHints(); + public byte HideWindowRaw(WindowHandle window) => T.HideWindowRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ResetKeyboard() => T.ResetKeyboard(); + public nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ) => T.Iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ResetLogPriorities() => T.ResetLogPriorities(); + public nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ) => T.Iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_close")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RestoreWindow(WindowHandle window) => T.RestoreWindow(window); + public int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd) => + T.IconvClose(cd); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [return: NativeTypeName("SDL_iconv_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RestoreWindowRaw(WindowHandle window) => T.RestoreWindowRaw(window); + public IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ) => T.IconvOpen(tocode, fromcode); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_iconv_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ResumeAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.ResumeAudioDevice(dev); + public IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ) => T.IconvOpen(tocode, fromcode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - T.ResumeAudioDeviceRaw(dev); + public sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => T.IconvString(tocode, fromcode, inbuf, inbytesleft); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => - T.ResumeAudioStreamDevice(stream); + public Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => T.IconvString(tocode, fromcode, inbuf, inbytesleft); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => - T.ResumeAudioStreamDeviceRaw(stream); + public MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => T.Init(flags); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ResumeHaptic(HapticHandle haptic) => T.ResumeHaptic(haptic); + public MaybeBool InitHapticRumble(HapticHandle haptic) => T.InitHapticRumble(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ResumeHapticRaw(HapticHandle haptic) => T.ResumeHapticRaw(haptic); + public byte InitHapticRumbleRaw(HapticHandle haptic) => T.InitHapticRumbleRaw(haptic); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RumbleGamepad( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleGamepad(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); + public byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => T.InitRaw(flags); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RumbleGamepadRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleGamepadRaw(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); + public MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + T.InitSubSystem(flags); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RumbleGamepadTriggers( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms); + public byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + T.InitSubSystemRaw(flags); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RumbleGamepadTriggersRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleGamepadTriggersRaw(gamepad, left_rumble, right_rumble, duration_ms); + public void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ) => T.InsertGPUDebugLabel(command_buffer, text); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RumbleJoystick( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleJoystick(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); + public void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ) => T.InsertGPUDebugLabel(command_buffer, text); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RumbleJoystickRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - T.RumbleJoystickRaw(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); + public IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] void* mem, + [NativeTypeName("size_t")] nuint size + ) => T.IOFromConstMem(mem, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RumbleJoystickTriggers( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleJoystickTriggers(joystick, left_rumble, right_rumble, duration_ms); + public IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] Ref mem, + [NativeTypeName("size_t")] nuint size + ) => T.IOFromConstMem(mem, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RumbleJoystickTriggersRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => T.RumbleJoystickTriggersRaw(joystick, left_rumble, right_rumble, duration_ms); + public IOStreamHandle IOFromDynamicMem() => T.IOFromDynamicMem(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool RunHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => T.RunHapticEffect(haptic, effect, iterations); + public IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("const char *")] sbyte* mode + ) => T.IOFromFile(file, mode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte RunHapticEffectRaw( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => T.RunHapticEffectRaw(haptic, effect, iterations); + public IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("const char *")] Ref mode + ) => T.IOFromFile(file, mode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => - T.SaveBMP(surface, file); + public IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => + T.IOFromMem(mem, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SaveBMP( - Ref surface, - [NativeTypeName("const char *")] Ref file - ) => T.SaveBMP(surface, file); + public IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) => + T.IOFromMem(mem, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SaveBMPIO( - Surface* surface, - IOStreamHandle dst, - [NativeTypeName("bool")] byte closeio - ) => T.SaveBMPIO(surface, dst, closeio); + public nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.IOvprintf(context, fmt, ap); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SaveBMPIO( - Ref surface, - IOStreamHandle dst, - [NativeTypeName("bool")] MaybeBool closeio - ) => T.SaveBMPIO(surface, dst, closeio); + public nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.IOvprintf(context, fmt, ap); - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_isalnum")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Surface* ScaleSurface( - Surface* surface, - int width, - int height, - ScaleMode scaleMode - ) => T.ScaleSurface(surface, width, height, scaleMode); + public int Isalnum(int x) => T.Isalnum(x); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_isalpha")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr ScaleSurface( - Ref surface, - int width, - int height, - ScaleMode scaleMode - ) => T.ScaleSurface(surface, width, height, scaleMode); + public int Isalpha(int x) => T.Isalpha(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [NativeFunction("SDL3", EntryPoint = "SDL_isblank")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ScreenKeyboardShown(WindowHandle window) => - T.ScreenKeyboardShown(window); + public int Isblank(int x) => T.Isblank(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [NativeFunction("SDL3", EntryPoint = "SDL_iscntrl")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ScreenKeyboardShownRaw(WindowHandle window) => T.ScreenKeyboardShownRaw(window); + public int Iscntrl(int x) => T.Iscntrl(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isdigit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int Isdigit(int x) => T.Isdigit(x); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ScreenSaverEnabled() => T.ScreenSaverEnabled(); + public MaybeBool IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.IsGamepad(instance_id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ScreenSaverEnabledRaw() => T.ScreenSaverEnabledRaw(); + public byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.IsGamepadRaw(instance_id); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_isgraph")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long SeekIO( - IOStreamHandle context, - [NativeTypeName("Sint64")] long offset, - IOWhence whence - ) => T.SeekIO(context, offset, whence); + public int Isgraph(int x) => T.Isgraph(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_isinf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] void* data, - int size - ) => T.SendGamepadEffect(gamepad, data, size); + public int Isinf(double x) => T.Isinf(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isinff")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int Isinff(float x) => T.Isinff(x); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] Ref data, - int size - ) => T.SendGamepadEffect(gamepad, data, size); + public MaybeBool IsJoystickHaptic(JoystickHandle joystick) => + T.IsJoystickHaptic(joystick); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] void* data, - int size - ) => T.SendJoystickEffect(joystick, data, size); + public byte IsJoystickHapticRaw(JoystickHandle joystick) => T.IsJoystickHapticRaw(joystick); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] Ref data, - int size - ) => T.SendJoystickEffect(joystick, data, size); + public MaybeBool IsJoystickVirtual( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => T.IsJoystickVirtual(instance_id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] float* data, - int num_values - ) => T.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); + public byte IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.IsJoystickVirtualRaw(instance_id); + + [NativeFunction("SDL3", EntryPoint = "SDL_islower")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int Islower(int x) => T.Islower(x); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] Ref data, - int num_values - ) => T.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); + public MaybeBool IsMouseHaptic() => T.IsMouseHaptic(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAppMetadata( - [NativeTypeName("const char *")] sbyte* appname, - [NativeTypeName("const char *")] sbyte* appversion, - [NativeTypeName("const char *")] sbyte* appidentifier - ) => T.SetAppMetadata(appname, appversion, appidentifier); + public byte IsMouseHapticRaw() => T.IsMouseHapticRaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_isnan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAppMetadata( - [NativeTypeName("const char *")] Ref appname, - [NativeTypeName("const char *")] Ref appversion, - [NativeTypeName("const char *")] Ref appidentifier - ) => T.SetAppMetadata(appname, appversion, appidentifier); + public int Isnan(double x) => T.Isnan(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_isnanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAppMetadataProperty( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => T.SetAppMetadataProperty(name, value); + public int Isnanf(float x) => T.Isnanf(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_isprint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => T.SetAppMetadataProperty(name, value); + public int Isprint(int x) => T.Isprint(x); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_ispunct")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - void* userdata - ) => T.SetAssertionHandler(handler, userdata); + public int Ispunct(int x) => T.Ispunct(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_isspace")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public int Isspace(int x) => T.Isspace(x); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - Ref userdata - ) => T.SetAssertionHandler(handler, userdata); + public MaybeBool IsTablet() => T.IsTablet(); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int SetAtomicInt(AtomicInt* a, int v) => T.SetAtomicInt(a, v); + public byte IsTabletRaw() => T.IsTabletRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public int SetAtomicInt(Ref a, int v) => T.SetAtomicInt(a, v); + public MaybeBool IsTV() => T.IsTV(); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void* SetAtomicPointer(void** a, void* v) => T.SetAtomicPointer(a, v); + public byte IsTVRaw() => T.IsTVRaw(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_isupper")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Ptr SetAtomicPointer(Ref2D a, Ref v) => T.SetAtomicPointer(a, v); + public int Isupper(int x) => T.Isupper(x); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_isxdigit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => - T.SetAtomicU32(a, v); + public int Isxdigit(int x) => T.Isxdigit(x); - [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) => - T.SetAtomicU32(a, v); + public sbyte* Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix) => + T.Itoa(value, str, radix); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioDeviceGain( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => T.SetAudioDeviceGain(devid, gain); + public Ptr Itoa(int value, [NativeTypeName("char *")] Ref str, int radix) => + T.Itoa(value, str, radix); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioDeviceGainRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => T.SetAudioDeviceGainRaw(devid, gain); + public MaybeBool JoystickConnected(JoystickHandle joystick) => + T.JoystickConnected(joystick); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - void* userdata - ) => T.SetAudioPostmixCallback(devid, callback, userdata); + public byte JoystickConnectedRaw(JoystickHandle joystick) => + T.JoystickConnectedRaw(joystick); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - Ref userdata - ) => T.SetAudioPostmixCallback(devid, callback, userdata); + public MaybeBool JoystickEventsEnabled() => T.JoystickEventsEnabled(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => T.SetAudioStreamFormat(stream, src_spec, dst_spec); + public byte JoystickEventsEnabledRaw() => T.JoystickEventsEnabledRaw(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) => T.SetAudioStreamFormat(stream, src_spec, dst_spec); + public byte KillProcess(ProcessHandle process, [NativeTypeName("bool")] byte force) => + T.KillProcess(process, force); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamFrequencyRatio( - AudioStreamHandle stream, - float ratio - ) => T.SetAudioStreamFrequencyRatio(stream, ratio); + public MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ) => T.KillProcess(process, force); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => - T.SetAudioStreamFrequencyRatioRaw(stream, ratio); + public sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => T.Lltoa(value, str, radix); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => - T.SetAudioStreamGain(stream, gain); + public Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ) => T.Lltoa(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => - T.SetAudioStreamGainRaw(stream, gain); + public Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => T.LoadBMP(file); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => T.SetAudioStreamGetCallback(stream, callback, userdata); + public Ptr LoadBMP([NativeTypeName("const char *")] Ref file) => + T.LoadBMP(file); + + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public Surface* LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => + T.LoadBMPIO(src, closeio); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) => T.SetAudioStreamGetCallback(stream, callback, userdata); + public Ptr LoadBMPIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => T.LoadBMPIO(src, closeio); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => T.SetAudioStreamInputChannelMap(stream, chmap, count); + public void* LoadFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("size_t *")] nuint* datasize + ) => T.LoadFile(file, datasize); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) => T.SetAudioStreamInputChannelMap(stream, chmap, count); + public Ptr LoadFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("size_t *")] Ref datasize + ) => T.LoadFile(file, datasize); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => T.SetAudioStreamOutputChannelMap(stream, chmap, count); + public void* LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] nuint* datasize, + [NativeTypeName("bool")] byte closeio + ) => T.LoadFileIO(src, datasize, closeio); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) => T.SetAudioStreamOutputChannelMap(stream, chmap, count); + public Ptr LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] Ref datasize, + [NativeTypeName("bool")] MaybeBool closeio + ) => T.LoadFileIO(src, datasize, closeio); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => T.SetAudioStreamPutCallback(stream, callback, userdata); + public FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] sbyte* name + ) => T.LoadFunction(handle, name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) => T.SetAudioStreamPutCallback(stream, callback, userdata); + public FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] Ref name + ) => T.LoadFunction(handle, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte value - ) => T.SetBooleanProperty(props, name, value); + public SharedObjectHandle LoadObject([NativeTypeName("const char *")] sbyte* sofile) => + T.LoadObject(sofile); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool value - ) => T.SetBooleanProperty(props, name, value); + public SharedObjectHandle LoadObject([NativeTypeName("const char *")] Ref sofile) => + T.LoadObject(sofile); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - void* userdata, - [NativeTypeName("const char **")] sbyte** mime_types, - [NativeTypeName("size_t")] nuint num_mime_types - ) => T.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); + public byte LoadWAV( + [NativeTypeName("const char *")] sbyte* path, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => T.LoadWAV(path, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - Ref userdata, - [NativeTypeName("const char **")] Ref2D mime_types, - [NativeTypeName("size_t")] nuint num_mime_types - ) => T.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); + public MaybeBool LoadWAV( + [NativeTypeName("const char *")] Ref path, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) => T.LoadWAV(path, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => - T.SetClipboardText(text); + public byte LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => T.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetClipboardText([NativeTypeName("const char *")] Ref text) => - T.SetClipboardText(text); + public MaybeBool LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) => T.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => - T.SetCurrentThreadPriority(priority); + public MaybeBool LockAudioStream(AudioStreamHandle stream) => + T.LockAudioStream(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => - T.SetCurrentThreadPriorityRaw(priority); + public byte LockAudioStreamRaw(AudioStreamHandle stream) => T.LockAudioStreamRaw(stream); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetCursor(CursorHandle cursor) => T.SetCursor(cursor); + public void LockJoysticks() => T.LockJoysticks(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetCursorRaw(CursorHandle cursor) => T.SetCursorRaw(cursor); + public void LockMutex(MutexHandle mutex) => T.LockMutex(mutex); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetErrorV( - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => T.SetErrorV(fmt, ap); + public MaybeBool LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + T.LockProperties(props); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetErrorV( - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => T.SetErrorV(fmt, ap); + public byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + T.LockPropertiesRaw(props); - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] byte enabled - ) => T.SetEventEnabled(type, enabled); + public void LockRWLockForReading(RWLockHandle rwlock) => T.LockRWLockForReading(rwlock); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] MaybeBool enabled - ) => T.SetEventEnabled(type, enabled); + public void LockRWLockForWriting(RWLockHandle rwlock) => T.LockRWLockForWriting(rwlock); - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => T.SetEventFilter(filter, userdata); + public void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + T.LockSpinlock(@lock); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => T.SetEventFilter(filter, userdata); + public void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => + T.LockSpinlock(@lock); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float value - ) => T.SetFloatProperty(props, name, value); + public byte LockSurface(Surface* surface) => T.LockSurface(surface); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float value - ) => T.SetFloatProperty(props, name, value); + public MaybeBool LockSurface(Ref surface) => T.LockSurface(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => - T.SetGamepadEventsEnabled(enabled); + public byte LockTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + void** pixels, + int* pitch + ) => T.LockTexture(texture, rect, pixels, pitch); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - T.SetGamepadEventsEnabled(enabled); + public MaybeBool LockTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D pixels, + Ref pitch + ) => T.LockTexture(texture, rect, pixels, pitch); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetGamepadLED( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => T.SetGamepadLED(gamepad, red, green, blue); + public byte LockTextureToSurface( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + Surface** surface + ) => T.LockTextureToSurface(texture, rect, surface); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetGamepadLEDRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => T.SetGamepadLEDRaw(gamepad, red, green, blue); + public MaybeBool LockTextureToSurface( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D surface + ) => T.LockTextureToSurface(texture, rect, surface); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_log")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] sbyte* mapping - ) => T.SetGamepadMapping(instance_id, mapping); + public double Log(double x) => T.Log(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_log10")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] Ref mapping - ) => T.SetGamepadMapping(instance_id, mapping); + public double Log10(double x) => T.Log10(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_log10f")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => - T.SetGamepadPlayerIndex(gamepad, player_index); + public float Log10F(float x) => T.Log10F(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_logf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => - T.SetGamepadPlayerIndexRaw(gamepad, player_index); + public float Logf(float x) => T.Logf(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] byte enabled - ) => T.SetGamepadSensorEnabled(gamepad, type, enabled); + public void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.LogMessageV(category, priority, fmt, ap); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] MaybeBool enabled - ) => T.SetGamepadSensorEnabled(gamepad, type, enabled); + public void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.LogMessageV(category, priority, fmt, ap); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lround")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => - T.SetHapticAutocenter(haptic, autocenter); + public nint Lround(double x) => T.Lround(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lroundf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => - T.SetHapticAutocenterRaw(haptic, autocenter); + public nint Lroundf(float x) => T.Lroundf(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetHapticGain(HapticHandle haptic, int gain) => - T.SetHapticGain(haptic, gain); + public sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => T.Ltoa(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetHapticGainRaw(HapticHandle haptic, int gain) => - T.SetHapticGainRaw(haptic, gain); + public Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => T.Ltoa(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetHint( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => T.SetHint(name, value); + public int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv) => T.Main(argc, argv); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public MaybeBool SetHint( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => T.SetHint(name, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetHintWithPriority( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value, - HintPriority priority - ) => T.SetHintWithPriority(name, value, priority); + public int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv) => + T.Main(argc, argv); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetHintWithPriority( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value, - HintPriority priority - ) => T.SetHintWithPriority(name, value, priority); + public Ptr Malloc([NativeTypeName("size_t")] nuint size) => T.Malloc(size); - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetInitialized(InitState* state, [NativeTypeName("bool")] byte initialized) => - T.SetInitialized(state, initialized); + public void* MallocRaw([NativeTypeName("size_t")] nuint size) => T.MallocRaw(size); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetInitialized( - Ref state, - [NativeTypeName("bool")] MaybeBool initialized - ) => T.SetInitialized(state, initialized); + public void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ) => T.MapGPUTransferBuffer(device, transfer_buffer, cycle); - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => - T.SetJoystickEventsEnabled(enabled); + public Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ) => T.MapGPUTransferBuffer(device, transfer_buffer, cycle); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - T.SetJoystickEventsEnabled(enabled); + public uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.MapRGB(format, palette, r, g, b); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickLED( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => T.SetJoystickLED(joystick, red, green, blue); + public uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.MapRGB(format, palette, r, g, b); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickLEDRaw( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => T.SetJoystickLEDRaw(joystick, red, green, blue); + public uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.MapRgba(format, palette, r, g, b, a); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickPlayerIndex(JoystickHandle joystick, int player_index) => - T.SetJoystickPlayerIndex(joystick, player_index); + public uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.MapRgba(format, palette, r, g, b, a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => - T.SetJoystickPlayerIndexRaw(joystick, player_index); + public uint MapSurfaceRGB( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.MapSurfaceRGB(surface, r, g, b); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickVirtualAxis( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => T.SetJoystickVirtualAxis(joystick, axis, value); + public uint MapSurfaceRGB( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.MapSurfaceRGB(surface, r, g, b); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickVirtualAxisRaw( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => T.SetJoystickVirtualAxisRaw(joystick, axis, value); + public uint MapSurfaceRgba( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.MapSurfaceRgba(surface, r, g, b, a); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickVirtualBall( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => T.SetJoystickVirtualBall(joystick, ball, xrel, yrel); + public uint MapSurfaceRgba( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.MapSurfaceRgba(surface, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickVirtualBallRaw( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => T.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); + public MaybeBool MaximizeWindow(WindowHandle window) => T.MaximizeWindow(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] byte down - ) => T.SetJoystickVirtualButton(joystick, button, down); + public byte MaximizeWindowRaw(WindowHandle window) => T.MaximizeWindowRaw(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] MaybeBool down - ) => T.SetJoystickVirtualButton(joystick, button, down); + public int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ) => T.Memcmp(s1, s2, len); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickVirtualHat( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => T.SetJoystickVirtualHat(joystick, hat, value); + public int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ) => T.Memcmp(s1, s2, len); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickVirtualHatRaw( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => T.SetJoystickVirtualHatRaw(joystick, hat, value); + public void MemoryBarrierAcquireFunction() => T.MemoryBarrierAcquireFunction(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] byte down, - float x, - float y, - float pressure - ) => T.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + public void MemoryBarrierReleaseFunction() => T.MemoryBarrierReleaseFunction(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] MaybeBool down, - float x, - float y, - float pressure - ) => T.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + public void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => T.Memset4(dst, val, dwords); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - void* userdata - ) => T.SetLogOutputFunction(callback, userdata); + public Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => T.Memset4(dst, val, dwords); + [return: NativeTypeName("SDL_MetalView")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - Ref userdata - ) => T.SetLogOutputFunction(callback, userdata); + public Ptr MetalCreateView(WindowHandle window) => T.MetalCreateView(window); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] + [return: NativeTypeName("SDL_MetalView")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetLogPriorities(LogPriority priority) => T.SetLogPriorities(priority); + public void* MetalCreateViewRaw(WindowHandle window) => T.MetalCreateViewRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetLogPriority(int category, LogPriority priority) => - T.SetLogPriority(category, priority); + public void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => + T.MetalDestroyView(view); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] sbyte* prefix - ) => T.SetLogPriorityPrefix(priority, prefix); + public void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) => + T.MetalDestroyView(view); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] Ref prefix - ) => T.SetLogPriorityPrefix(priority, prefix); + public void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => + T.MetalGetLayer(view); - [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => - T.SetModState(modstate); + public Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) => + T.MetalGetLayer(view); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long value - ) => T.SetNumberProperty(props, name, value); + public MaybeBool MinimizeWindow(WindowHandle window) => T.MinimizeWindow(window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long value - ) => T.SetNumberProperty(props, name, value); + public byte MinimizeWindowRaw(WindowHandle window) => T.MinimizeWindowRaw(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetPaletteColors( - Palette* palette, - [NativeTypeName("const SDL_Color *")] Color* colors, - int firstcolor, - int ncolors - ) => T.SetPaletteColors(palette, colors, firstcolor, ncolors); + public byte MixAudio( + [NativeTypeName("Uint8 *")] byte* dst, + [NativeTypeName("const Uint8 *")] byte* src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) => T.MixAudio(dst, src, format, len, volume); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetPaletteColors( - Ref palette, - [NativeTypeName("const SDL_Color *")] Ref colors, - int firstcolor, - int ncolors - ) => T.SetPaletteColors(palette, colors, firstcolor, ncolors); + public MaybeBool MixAudio( + [NativeTypeName("Uint8 *")] Ref dst, + [NativeTypeName("const Uint8 *")] Ref src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) => T.MixAudio(dst, src, format, len, volume); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value - ) => T.SetPointerProperty(props, name, value); + public double Modf(double x, double* y) => T.Modf(x, y); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value - ) => T.SetPointerProperty(props, name, value); + public double Modf(double x, Ref y) => T.Modf(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - void* userdata - ) => T.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + public float Modff(float x, float* y) => T.Modff(x, y); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - Ref userdata - ) => T.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + public float Modff(float x, Ref y) => T.Modff(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => - T.SetPrimarySelectionText(text); + public uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) => T.Murmur3X32(data, len, seed); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetPrimarySelectionText( - [NativeTypeName("const char *")] Ref text - ) => T.SetPrimarySelectionText(text); + public uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) => T.Murmur3X32(data, len, seed); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => T.SetRenderClipRect(renderer, rect); + public void OnApplicationDidEnterBackground() => T.OnApplicationDidEnterBackground(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => T.SetRenderClipRect(renderer, rect); + public void OnApplicationDidEnterForeground() => T.OnApplicationDidEnterForeground(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => - T.SetRenderColorScale(renderer, scale); + public void OnApplicationDidReceiveMemoryWarning() => + T.OnApplicationDidReceiveMemoryWarning(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => - T.SetRenderColorScaleRaw(renderer, scale); + public void OnApplicationWillEnterBackground() => T.OnApplicationWillEnterBackground(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetRenderDrawBlendMode(renderer, blendMode); + public void OnApplicationWillEnterForeground() => T.OnApplicationWillEnterForeground(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderDrawBlendModeRaw( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetRenderDrawBlendModeRaw(renderer, blendMode); + public void OnApplicationWillTerminate() => T.OnApplicationWillTerminate(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.SetRenderDrawColor(renderer, r, g, b, a); + public uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec + ) => T.OpenAudioDevice(devid, spec); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_AudioDeviceID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderDrawColorFloat( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => T.SetRenderDrawColorFloat(renderer, r, g, b, a); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + public uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec + ) => T.OpenAudioDevice(devid, spec); + + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderDrawColorFloatRaw( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => T.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); + public AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => T.OpenAudioDeviceStream(devid, spec, callback, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderDrawColorRaw( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.SetRenderDrawColorRaw(renderer, r, g, b, a); + public AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) => T.OpenAudioDeviceStream(devid, spec, callback, userdata); + + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec + ) => T.OpenCamera(instance_id, spec); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderLogicalPresentation( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => T.SetRenderLogicalPresentation(renderer, w, h, mode); + public CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] Ref spec + ) => T.OpenCamera(instance_id, spec); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderLogicalPresentationRaw( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => T.SetRenderLogicalPresentationRaw(renderer, w, h, mode); + public StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => + T.OpenFileStorage(path); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderScale( - RendererHandle renderer, - float scaleX, - float scaleY - ) => T.SetRenderScale(renderer, scaleX, scaleY); + public StorageHandle OpenFileStorage([NativeTypeName("const char *")] Ref path) => + T.OpenFileStorage(path); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => - T.SetRenderScaleRaw(renderer, scaleX, scaleY); + public GamepadHandle OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.OpenGamepad(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderTarget(RendererHandle renderer, Texture* texture) => - T.SetRenderTarget(renderer, texture); + public HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => + T.OpenHaptic(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) => - T.SetRenderTarget(renderer, texture); + public HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => + T.OpenHapticFromJoystick(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => T.SetRenderViewport(renderer, rect); + public HapticHandle OpenHapticFromMouse() => T.OpenHapticFromMouse(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => T.SetRenderViewport(renderer, rect); + public IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, + void* userdata + ) => T.OpenIO(iface, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => - T.SetRenderVSync(renderer, vsync); + public IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, + Ref userdata + ) => T.OpenIO(iface, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => - T.SetRenderVSyncRaw(renderer, vsync); + public JoystickHandle OpenJoystick([NativeTypeName("SDL_JoystickID")] uint instance_id) => + T.OpenJoystick(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] sbyte* name - ) => T.SetScancodeName(scancode, name); + public SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => + T.OpenSensor(instance_id); + + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, + void* userdata + ) => T.OpenStorage(iface, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] Ref name - ) => T.SetScancodeName(scancode, name); + public StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] Ref iface, + Ref userdata + ) => T.OpenStorage(iface, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => T.SetStringProperty(props, name, value); + public StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] sbyte* @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.OpenTitleStorage(@override, props); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => T.SetStringProperty(props, name, value); + public StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] Ref @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.OpenTitleStorage(@override, props); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => - T.SetSurfaceAlphaMod(surface, alpha); + public byte OpenURL([NativeTypeName("const char *")] sbyte* url) => T.OpenURL(url); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8")] byte alpha - ) => T.SetSurfaceAlphaMod(surface, alpha); + public MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) => + T.OpenURL(url); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetSurfaceBlendMode(surface, blendMode); + public StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.OpenUserStorage(org, app, props); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.OpenUserStorage(org, app, props); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetSurfaceBlendMode(surface, blendMode); + public MaybeBool OutOfMemory() => T.OutOfMemory(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceClipRect( - Surface* surface, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => T.SetSurfaceClipRect(surface, rect); + public byte OutOfMemoryRaw() => T.OutOfMemoryRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceClipRect( - Ref surface, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => T.SetSurfaceClipRect(surface, rect); + public MaybeBool PauseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.PauseAudioDevice(dev); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceColorKey( - Surface* surface, - [NativeTypeName("bool")] byte enabled, - [NativeTypeName("Uint32")] uint key - ) => T.SetSurfaceColorKey(surface, enabled, key); + public byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.PauseAudioDeviceRaw(dev); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceColorKey( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled, - [NativeTypeName("Uint32")] uint key - ) => T.SetSurfaceColorKey(surface, enabled, key); + public MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => + T.PauseAudioStreamDevice(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.SetSurfaceColorMod(surface, r, g, b); + public byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => + T.PauseAudioStreamDeviceRaw(stream); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.SetSurfaceColorMod(surface, r, g, b); + public MaybeBool PauseHaptic(HapticHandle haptic) => T.PauseHaptic(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => - T.SetSurfaceColorspace(surface, colorspace); + public byte PauseHapticRaw(HapticHandle haptic) => T.PauseHapticRaw(haptic); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceColorspace(Ref surface, Colorspace colorspace) => - T.SetSurfaceColorspace(surface, colorspace); + public int PeepEvents( + Event* events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => T.PeepEvents(events, numevents, action, minType, maxType); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfacePalette(Surface* surface, Palette* palette) => - T.SetSurfacePalette(surface, palette); + public int PeepEvents( + Ref events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => T.PeepEvents(events, numevents, action, minType, maxType); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfacePalette(Ref surface, Ref palette) => - T.SetSurfacePalette(surface, palette); + public MaybeBool PlayHapticRumble( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => T.PlayHapticRumble(haptic, strength, length); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => - T.SetSurfaceRLE(surface, enabled); + public byte PlayHapticRumbleRaw( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => T.PlayHapticRumbleRaw(haptic, strength, length); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetSurfaceRLE( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled - ) => T.SetSurfaceRLE(surface, enabled); + public byte PollEvent(Event* @event) => T.PollEvent(@event); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextInputArea( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int cursor - ) => T.SetTextInputArea(window, rect, cursor); + public MaybeBool PollEvent(Ref @event) => T.PollEvent(@event); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_PopGPUDebugGroup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextInputArea( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect, - int cursor - ) => T.SetTextInputArea(window, rect, cursor); + public void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer) => + T.PopGPUDebugGroup(command_buffer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_pow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => - T.SetTextureAlphaMod(texture, alpha); + public double Pow(double x, double y) => T.Pow(x, y); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_powf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8")] byte alpha - ) => T.SetTextureAlphaMod(texture, alpha); + public float Powf(float x, float y) => T.Powf(x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureAlphaModFloat(Texture* texture, float alpha) => - T.SetTextureAlphaModFloat(texture, alpha); + public byte PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch, + [NativeTypeName("bool")] byte linear + ) => + T.PremultiplyAlpha( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch, + linear + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) => - T.SetTextureAlphaModFloat(texture, alpha); + public MaybeBool PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch, + [NativeTypeName("bool")] MaybeBool linear + ) => + T.PremultiplyAlpha( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch, + linear + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetTextureBlendMode(texture, blendMode); + public byte PremultiplySurfaceAlpha( + Surface* surface, + [NativeTypeName("bool")] byte linear + ) => T.PremultiplySurfaceAlpha(surface, linear); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => T.SetTextureBlendMode(texture, blendMode); + public MaybeBool PremultiplySurfaceAlpha( + Ref surface, + [NativeTypeName("bool")] MaybeBool linear + ) => T.PremultiplySurfaceAlpha(surface, linear); + + [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void PumpEvents() => T.PumpEvents(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.SetTextureColorMod(texture, r, g, b); + public byte PushEvent(Event* @event) => T.PushEvent(@event); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => T.SetTextureColorMod(texture, r, g, b); + public MaybeBool PushEvent(Ref @event) => T.PushEvent(@event); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => - T.SetTextureColorModFloat(texture, r, g, b); + public void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUComputeUniformData(command_buffer, slot_index, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureColorModFloat( - Ref texture, - float r, - float g, - float b - ) => T.SetTextureColorModFloat(texture, r, g, b); + public void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUComputeUniformData(command_buffer, slot_index, data, length); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => - T.SetTextureScaleMode(texture, scaleMode); + public void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ) => T.PushGPUDebugGroup(command_buffer, name); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) => - T.SetTextureScaleMode(texture, scaleMode); + public void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ) => T.PushGPUDebugGroup(command_buffer, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetTLS( - [NativeTypeName("SDL_TLSID *")] AtomicInt* id, - [NativeTypeName("const void *")] void* value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor - ) => T.SetTLS(id, value, destructor); + public void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUFragmentUniformData(command_buffer, slot_index, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetTLS( - [NativeTypeName("SDL_TLSID *")] Ref id, - [NativeTypeName("const void *")] Ref value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor - ) => T.SetTLS(id, value, destructor); + public void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUFragmentUniformData(command_buffer, slot_index, data, length); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] byte on_top - ) => T.SetWindowAlwaysOnTop(window, on_top); + public void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUVertexUniformData(command_buffer, slot_index, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool on_top - ) => T.SetWindowAlwaysOnTop(window, on_top); + public void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => T.PushGPUVertexUniformData(command_buffer, slot_index, data, length); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowAspectRatio( - WindowHandle window, - float min_aspect, - float max_aspect - ) => T.SetWindowAspectRatio(window, min_aspect, max_aspect); + public byte PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] void* buf, + int len + ) => T.PutAudioStreamData(stream, buf, len); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowAspectRatioRaw( - WindowHandle window, - float min_aspect, - float max_aspect - ) => T.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); + public MaybeBool PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] Ref buf, + int len + ) => T.PutAudioStreamData(stream, buf, len); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowBordered( - WindowHandle window, - [NativeTypeName("bool")] byte bordered - ) => T.SetWindowBordered(window, bordered); + public void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => T.Qsort(@base, nmemb, size, compare); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowBordered( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool bordered - ) => T.SetWindowBordered(window, bordered); + public void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => T.Qsort(@base, nmemb, size, compare); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] byte focusable - ) => T.SetWindowFocusable(window, focusable); + public void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => T.QsortR(@base, nmemb, size, compare, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool focusable - ) => T.SetWindowFocusable(window, focusable); + public void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) => T.QsortR(@base, nmemb, size, compare, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] byte fullscreen - ) => T.SetWindowFullscreen(window, fullscreen); + public MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + T.QueryGPUFence(device, fence); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool fullscreen - ) => T.SetWindowFullscreen(window, fullscreen); + public byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence) => + T.QueryGPUFenceRaw(device, fence); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode - ) => T.SetWindowFullscreenMode(window, mode); + public void Quit() => T.Quit(); + + [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + T.QuitSubSystem(flags); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] Ref mode - ) => T.SetWindowFullscreenMode(window, mode); + public MaybeBool RaiseWindow(WindowHandle window) => T.RaiseWindow(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - void* callback_data - ) => T.SetWindowHitTest(window, callback, callback_data); + public byte RaiseWindowRaw(WindowHandle window) => T.RaiseWindowRaw(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - Ref callback_data - ) => T.SetWindowHitTest(window, callback, callback_data); + public int Rand([NativeTypeName("Sint32")] int n) => T.Rand(n); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowIcon(WindowHandle window, Surface* icon) => - T.SetWindowIcon(window, icon); + public uint RandBits() => T.RandBits(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state) => T.RandBitsR(state); + + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowIcon(WindowHandle window, Ref icon) => - T.SetWindowIcon(window, icon); + public uint RandBitsR([NativeTypeName("Uint64 *")] Ref state) => T.RandBitsR(state); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowKeyboardGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => T.SetWindowKeyboardGrab(window, grabbed); + public int RandR( + [NativeTypeName("Uint64 *")] ulong* state, + [NativeTypeName("Sint32")] int n + ) => T.RandR(state, n); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Sint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowKeyboardGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => T.SetWindowKeyboardGrab(window, grabbed); + public int RandR( + [NativeTypeName("Uint64 *")] Ref state, + [NativeTypeName("Sint32")] int n + ) => T.RandR(state, n); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public float Randf() => T.Randf(); + + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public float RandfR([NativeTypeName("Uint64 *")] ulong* state) => T.RandfR(state); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => - T.SetWindowMaximumSize(window, max_w, max_h); + public float RandfR([NativeTypeName("Uint64 *")] Ref state) => T.RandfR(state); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => - T.SetWindowMaximumSizeRaw(window, max_w, max_h); + public nuint ReadIO( + IOStreamHandle context, + void* ptr, + [NativeTypeName("size_t")] nuint size + ) => T.ReadIO(context, ptr, size); - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => - T.SetWindowMinimumSize(window, min_w, min_h); + public nuint ReadIO( + IOStreamHandle context, + Ref ptr, + [NativeTypeName("size_t")] nuint size + ) => T.ReadIO(context, ptr, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => - T.SetWindowMinimumSizeRaw(window, min_w, min_h); + public void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ) => T.ReadProcess(process, datasize, exitcode); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ) => T.ReadProcess(process, datasize, exitcode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => - T.SetWindowModal(window, modal); + public byte ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + T.ReadS16BE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowModal( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool modal - ) => T.SetWindowModal(window, modal); + public MaybeBool ReadS16BE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) => T.ReadS16BE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => T.SetWindowMouseGrab(window, grabbed); + public byte ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + T.ReadS16LE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => T.SetWindowMouseGrab(window, grabbed); + public MaybeBool ReadS16LE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) => T.ReadS16LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => T.SetWindowMouseRect(window, rect); + public byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + T.ReadS32BE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => T.SetWindowMouseRect(window, rect); + public MaybeBool ReadS32BE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) => T.ReadS32BE(src, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + T.ReadS32LE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => - T.SetWindowOpacity(window, opacity); + public MaybeBool ReadS32LE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) => T.ReadS32LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowOpacityRaw(WindowHandle window, float opacity) => - T.SetWindowOpacityRaw(window, opacity); + public byte ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => + T.ReadS64BE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => - T.SetWindowParent(window, parent); + public MaybeBool ReadS64BE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) => T.ReadS64BE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => - T.SetWindowParentRaw(window, parent); + public byte ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => + T.ReadS64LE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => - T.SetWindowPosition(window, x, y); + public MaybeBool ReadS64LE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) => T.ReadS64LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowPositionRaw(WindowHandle window, int x, int y) => - T.SetWindowPositionRaw(window, x, y); + public byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => + T.ReadS8(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] byte enabled - ) => T.SetWindowRelativeMouseMode(window, enabled); + public MaybeBool ReadS8( + IOStreamHandle src, + [NativeTypeName("Sint8 *")] Ref value + ) => T.ReadS8(src, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + void* destination, + [NativeTypeName("Uint64")] ulong length + ) => T.ReadStorageFile(storage, path, destination, length); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool enabled - ) => T.SetWindowRelativeMouseMode(window, enabled); + public MaybeBool ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref destination, + [NativeTypeName("Uint64")] ulong length + ) => T.ReadStorageFile(storage, path, destination, length); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] byte resizable - ) => T.SetWindowResizable(window, resizable); + public byte ReadSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => T.ReadSurfacePixel(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool resizable - ) => T.SetWindowResizable(window, resizable); + public MaybeBool ReadSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => T.ReadSurfacePixel(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowShape(WindowHandle window, Surface* shape) => - T.SetWindowShape(window, shape); + public byte ReadSurfacePixelFloat( + Surface* surface, + int x, + int y, + float* r, + float* g, + float* b, + float* a + ) => T.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowShape(WindowHandle window, Ref shape) => - T.SetWindowShape(window, shape); + public MaybeBool ReadSurfacePixelFloat( + Ref surface, + int x, + int y, + Ref r, + Ref g, + Ref b, + Ref a + ) => T.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowSize(WindowHandle window, int w, int h) => - T.SetWindowSize(window, w, h); + public byte ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => + T.ReadU16BE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowSizeRaw(WindowHandle window, int w, int h) => - T.SetWindowSizeRaw(window, w, h); + public MaybeBool ReadU16BE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) => T.ReadU16BE(src, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => - T.SetWindowSurfaceVSync(window, vsync); + public byte ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => + T.ReadU16LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => - T.SetWindowSurfaceVSyncRaw(window, vsync); + public MaybeBool ReadU16LE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) => T.ReadU16LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* title - ) => T.SetWindowTitle(window, title); + public byte ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + T.ReadU32BE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] Ref title - ) => T.SetWindowTitle(window, title); + public MaybeBool ReadU32BE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) => T.ReadU32BE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShouldInit(InitState* state) => T.ShouldInit(state); + public byte ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + T.ReadU32LE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShouldInit(Ref state) => T.ShouldInit(state); + public MaybeBool ReadU32LE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) => T.ReadU32LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShouldQuit(InitState* state) => T.ShouldQuit(state); + public byte ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + T.ReadU64BE(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShouldQuit(Ref state) => T.ShouldQuit(state); + public MaybeBool ReadU64BE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) => T.ReadU64BE(src, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShowCursor() => T.ShowCursor(); + public byte ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + T.ReadU64LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShowCursorRaw() => T.ShowCursorRaw(); + public MaybeBool ReadU64LE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) => T.ReadU64LE(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, - int* buttonid - ) => T.ShowMessageBox(messageboxdata, buttonid); + public byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => + T.ReadU8(src, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, - Ref buttonid - ) => T.ShowMessageBox(messageboxdata, buttonid); + public MaybeBool ReadU8( + IOStreamHandle src, + [NativeTypeName("Uint8 *")] Ref value + ) => T.ReadU8(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => - T.ShowOpenFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location, - allow_many - ); + public void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size) => + T.Realloc(mem, size); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many - ) => - T.ShowOpenFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location, - allow_many - ); + public Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size) => T.Realloc(mem, size); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => T.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); + public uint RegisterEvents(int numevents) => T.RegisterEvents(numevents); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many - ) => T.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); + public void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => + T.ReleaseCameraFrame(camera, frame); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location - ) => T.ShowSaveFileDialog(callback, userdata, window, filters, nfilters, default_location); + public void ReleaseCameraFrame(CameraHandle camera, Ref frame) => + T.ReleaseCameraFrame(camera, frame); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location - ) => T.ShowSaveFileDialog(callback, userdata, window, filters, nfilters, default_location); + public void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer) => + T.ReleaseGPUBuffer(device, buffer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] sbyte* title, - [NativeTypeName("const char *")] sbyte* message, - WindowHandle window - ) => T.ShowSimpleMessageBox(flags, title, message, window); + public void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ) => T.ReleaseGPUComputePipeline(device, compute_pipeline); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUFence")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] Ref title, - [NativeTypeName("const char *")] Ref message, - WindowHandle window - ) => T.ShowSimpleMessageBox(flags, title, message, window); + public void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + T.ReleaseGPUFence(device, fence); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShowWindow(WindowHandle window) => T.ShowWindow(window); + public void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ) => T.ReleaseGPUGraphicsPipeline(device, graphics_pipeline); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUSampler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShowWindowRaw(WindowHandle window) => T.ShowWindowRaw(window); + public void ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler) => + T.ReleaseGPUSampler(device, sampler); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUShader")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => - T.ShowWindowSystemMenu(window, x, y); + public void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader) => + T.ReleaseGPUShader(device, shader); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => - T.ShowWindowSystemMenuRaw(window, x, y); + public void ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture) => + T.ReleaseGPUTexture(device, texture); - [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SignalCondition(ConditionHandle cond) => T.SignalCondition(cond); + public void ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => T.ReleaseGPUTransferBuffer(device, transfer_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void SignalSemaphore(SemaphoreHandle sem) => T.SignalSemaphore(sem); + public void ReleaseWindowFromGPUDevice(GPUDeviceHandle device, WindowHandle window) => + T.ReleaseWindowFromGPUDevice(device, window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StartTextInput(WindowHandle window) => T.StartTextInput(window); + public MaybeBool ReloadGamepadMappings() => T.ReloadGamepadMappings(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StartTextInputRaw(WindowHandle window) => T.StartTextInputRaw(window); + public byte ReloadGamepadMappingsRaw() => T.ReloadGamepadMappingsRaw(); + + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => T.RemoveEventWatch(filter, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StartTextInputWithProperties( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.StartTextInputWithProperties(window, props); + public void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => T.RemoveEventWatch(filter, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StartTextInputWithPropertiesRaw( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => T.StartTextInputWithPropertiesRaw(window, props); + public void RemoveHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => T.RemoveHintCallback(name, callback, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => - T.StopHapticEffect(haptic, effect); + public void RemoveHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) => T.RemoveHintCallback(name, callback, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StopHapticEffectRaw(HapticHandle haptic, int effect) => - T.StopHapticEffectRaw(haptic, effect); + public byte RemovePath([NativeTypeName("const char *")] sbyte* path) => T.RemovePath(path); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StopHapticEffects(HapticHandle haptic) => - T.StopHapticEffects(haptic); + public MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) => + T.RemovePath(path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StopHapticEffectsRaw(HapticHandle haptic) => T.StopHapticEffectsRaw(haptic); + public byte RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => T.RemoveStoragePath(storage, path); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StopHapticRumble(HapticHandle haptic) => T.StopHapticRumble(haptic); + public MaybeBool RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) => T.RemoveStoragePath(storage, path); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StopHapticRumbleRaw(HapticHandle haptic) => T.StopHapticRumbleRaw(haptic); + public void RemoveSurfaceAlternateImages(Surface* surface) => + T.RemoveSurfaceAlternateImages(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StopTextInput(WindowHandle window) => T.StopTextInput(window); + public void RemoveSurfaceAlternateImages(Ref surface) => + T.RemoveSurfaceAlternateImages(surface); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StopTextInputRaw(WindowHandle window) => T.StopTextInputRaw(window); + public MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => + T.RemoveTimer(id); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool StorageReady(StorageHandle storage) => T.StorageReady(storage); + public byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => T.RemoveTimerRaw(id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte StorageReadyRaw(StorageHandle storage) => T.StorageReadyRaw(storage); + public byte RenamePath( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => T.RenamePath(oldpath, newpath); - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => - T.StringToGuid(pchGUID); + public MaybeBool RenamePath( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => T.RenamePath(oldpath, newpath); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) => - T.StringToGuid(pchGUID); + public byte RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => T.RenameStoragePath(storage, oldpath, newpath); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SurfaceHasAlternateImages(Surface* surface) => - T.SurfaceHasAlternateImages(surface); + public MaybeBool RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => T.RenameStoragePath(storage, oldpath, newpath); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SurfaceHasAlternateImages(Ref surface) => - T.SurfaceHasAlternateImages(surface); + public MaybeBool RenderClear(RendererHandle renderer) => T.RenderClear(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SurfaceHasColorKey(Surface* surface) => T.SurfaceHasColorKey(surface); + public byte RenderClearRaw(RendererHandle renderer) => T.RenderClearRaw(renderer); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SurfaceHasColorKey(Ref surface) => - T.SurfaceHasColorKey(surface); + public MaybeBool RenderClipEnabled(RendererHandle renderer) => + T.RenderClipEnabled(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte SurfaceHasRLE(Surface* surface) => T.SurfaceHasRLE(surface); + public byte RenderClipEnabledRaw(RendererHandle renderer) => + T.RenderClipEnabledRaw(renderer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SurfaceHasRLE(Ref surface) => T.SurfaceHasRLE(surface); + public byte RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + float* x, + float* y + ) => T.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool SyncWindow(WindowHandle window) => T.SyncWindow(window); + public MaybeBool RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + Ref x, + Ref y + ) => T.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public byte SyncWindowRaw(WindowHandle window) => T.SyncWindowRaw(window); - - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long TellIO(IOStreamHandle context) => T.TellIO(context); + public byte RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + float* window_x, + float* window_y + ) => T.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TextInputActive(WindowHandle window) => T.TextInputActive(window); + public MaybeBool RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + Ref window_x, + Ref window_y + ) => T.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TextInputActiveRaw(WindowHandle window) => T.TextInputActiveRaw(window); + public byte RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] sbyte* str + ) => T.RenderDebugText(renderer, x, y, str); - [return: NativeTypeName("SDL_Time")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public long TimeFromWindows( - [NativeTypeName("Uint32")] uint dwLowDateTime, - [NativeTypeName("Uint32")] uint dwHighDateTime - ) => T.TimeFromWindows(dwLowDateTime, dwHighDateTime); + public MaybeBool RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] Ref str + ) => T.RenderDebugText(renderer, x, y, str); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - DateTime* dt, - [NativeTypeName("bool")] byte localTime - ) => T.TimeToDateTime(ticks, dt, localTime); + public byte RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => T.RenderFillRect(renderer, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - Ref dt, - [NativeTypeName("bool")] MaybeBool localTime - ) => T.TimeToDateTime(ticks, dt, localTime); + public MaybeBool RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) => T.RenderFillRect(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] uint* dwLowDateTime, - [NativeTypeName("Uint32 *")] uint* dwHighDateTime - ) => T.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); + public byte RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => T.RenderFillRects(renderer, rects, count); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] Ref dwLowDateTime, - [NativeTypeName("Uint32 *")] Ref dwHighDateTime - ) => T.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); + public MaybeBool RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) => T.RenderFillRects(renderer, rects, count); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TryLockMutex(MutexHandle mutex) => T.TryLockMutex(mutex); + public byte RenderGeometry( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, + int num_vertices, + [NativeTypeName("const int *")] int* indices, + int num_indices + ) => T.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TryLockMutexRaw(MutexHandle mutex) => T.TryLockMutexRaw(mutex); + public MaybeBool RenderGeometry( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_Vertex *")] Ref vertices, + int num_vertices, + [NativeTypeName("const int *")] Ref indices, + int num_indices + ) => T.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => - T.TryLockRWLockForReading(rwlock); + public byte RenderGeometryRaw( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const float *")] float* xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] FColor* color, + int color_stride, + [NativeTypeName("const float *")] float* uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] void* indices, + int num_indices, + int size_indices + ) => + T.RenderGeometryRaw( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TryLockRWLockForReadingRaw(RWLockHandle rwlock) => - T.TryLockRWLockForReadingRaw(rwlock); + public MaybeBool RenderGeometryRaw( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const float *")] Ref xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] Ref color, + int color_stride, + [NativeTypeName("const float *")] Ref uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] Ref indices, + int num_indices, + int size_indices + ) => + T.RenderGeometryRaw( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => - T.TryLockRWLockForWriting(rwlock); + public MaybeBool RenderLine( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => T.RenderLine(renderer, x1, y1, x2, y2); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TryLockRWLockForWritingRaw(RWLockHandle rwlock) => - T.TryLockRWLockForWritingRaw(rwlock); + public byte RenderLineRaw( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => T.RenderLineRaw(renderer, x1, y1, x2, y2); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - T.TryLockSpinlock(@lock); + public byte RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => T.RenderLines(renderer, points, count); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => - T.TryLockSpinlock(@lock); + public MaybeBool RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) => T.RenderLines(renderer, points, count); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => T.TryWaitSemaphore(sem); + public MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => + T.RenderPoint(renderer, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => T.TryWaitSemaphoreRaw(sem); + public byte RenderPointRaw(RendererHandle renderer, float x, float y) => + T.RenderPointRaw(renderer, x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnbindAudioStream(AudioStreamHandle stream) => T.UnbindAudioStream(stream); + public byte RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => T.RenderPoints(renderer, points, count); - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams) => - T.UnbindAudioStreams(streams, num_streams); + public MaybeBool RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) => T.RenderPoints(renderer, points, count); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnbindAudioStreams(Ref streams, int num_streams) => - T.UnbindAudioStreams(streams, num_streams); + public MaybeBool RenderPresent(RendererHandle renderer) => T.RenderPresent(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_UnloadObject")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnloadObject(SharedObjectHandle handle) => T.UnloadObject(handle); + public byte RenderPresentRaw(RendererHandle renderer) => T.RenderPresentRaw(renderer); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UnlockAudioStream(AudioStreamHandle stream) => - T.UnlockAudioStream(stream); + public Surface* RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => T.RenderReadPixels(renderer, rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UnlockAudioStreamRaw(AudioStreamHandle stream) => - T.UnlockAudioStreamRaw(stream); + public Ptr RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => T.RenderReadPixels(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockJoysticks")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockJoysticks() => T.UnlockJoysticks(); + public byte RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => T.RenderRect(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockMutex")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockMutex(MutexHandle mutex) => T.UnlockMutex(mutex); + public MaybeBool RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) => T.RenderRect(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - T.UnlockProperties(props); + public byte RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => T.RenderRects(renderer, rects, count); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockRWLock")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockRWLock(RWLockHandle rwlock) => T.UnlockRWLock(rwlock); + public MaybeBool RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) => T.RenderRects(renderer, rects, count); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - T.UnlockSpinlock(@lock); + public byte RenderTexture( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => T.RenderTexture(renderer, texture, srcrect, dstrect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => - T.UnlockSpinlock(@lock); + public MaybeBool RenderTexture( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => T.RenderTexture(renderer, texture, srcrect, dstrect); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockSurface(Surface* surface) => T.UnlockSurface(surface); + public byte RenderTexture9Grid( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => + T.RenderTexture9Grid( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockSurface(Ref surface) => T.UnlockSurface(surface); + public MaybeBool RenderTexture9Grid( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => + T.RenderTexture9Grid( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockTexture(Texture* texture) => T.UnlockTexture(texture); + public byte RenderTextureRotated( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] FPoint* center, + FlipMode flip + ) => T.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UnlockTexture(Ref texture) => T.UnlockTexture(texture); + public MaybeBool RenderTextureRotated( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] Ref center, + FlipMode flip + ) => T.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UpdateGamepads() => T.UpdateGamepads(); + public byte RenderTextureTiled( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => T.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data - ) => T.UpdateHapticEffect(haptic, effect, data); + public MaybeBool RenderTextureTiled( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => T.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] Ref data - ) => T.UpdateHapticEffect(haptic, effect, data); + public MaybeBool RenderViewportSet(RendererHandle renderer) => + T.RenderViewportSet(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateJoysticks")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UpdateJoysticks() => T.UpdateJoysticks(); + public byte RenderViewportSetRaw(RendererHandle renderer) => + T.RenderViewportSetRaw(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateNVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* UVplane, - int UVpitch - ) => T.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); + public AssertState ReportAssertion( + AssertData* data, + [NativeTypeName("const char *")] sbyte* func, + [NativeTypeName("const char *")] sbyte* file, + int line + ) => T.ReportAssertion(data, func, file, line); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateNVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref UVplane, - int UVpitch - ) => T.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); + public AssertState ReportAssertion( + Ref data, + [NativeTypeName("const char *")] Ref func, + [NativeTypeName("const char *")] Ref file, + int line + ) => T.ReportAssertion(data, func, file, line); - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateSensors")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void UpdateSensors() => T.UpdateSensors(); + public void ResetAssertionReport() => T.ResetAssertionReport(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const void *")] void* pixels, - int pitch - ) => T.UpdateTexture(texture, rect, pixels, pitch); + public byte ResetHint([NativeTypeName("const char *")] sbyte* name) => T.ResetHint(name); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const void *")] Ref pixels, - int pitch - ) => T.UpdateTexture(texture, rect, pixels, pitch); + public MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) => + T.ResetHint(name); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateWindowSurface(WindowHandle window) => - T.UpdateWindowSurface(window); + public void ResetHints() => T.ResetHints(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateWindowSurfaceRaw(WindowHandle window) => T.UpdateWindowSurfaceRaw(window); + public void ResetKeyboard() => T.ResetKeyboard(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int numrects - ) => T.UpdateWindowSurfaceRects(window, rects, numrects); + public void ResetLogPriorities() => T.ResetLogPriorities(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int numrects - ) => T.UpdateWindowSurfaceRects(window, rects, numrects); + public MaybeBool RestoreWindow(WindowHandle window) => T.RestoreWindow(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte UpdateYUVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] byte* Vplane, - int Vpitch - ) => T.UpdateYUVTexture(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + public byte RestoreWindowRaw(WindowHandle window) => T.RestoreWindowRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool UpdateYUVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] Ref Vplane, - int Vpitch - ) => T.UpdateYUVTexture(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + public MaybeBool ResumeAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.ResumeAudioDevice(dev); - [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void WaitCondition(ConditionHandle cond, MutexHandle mutex) => - T.WaitCondition(cond, mutex); + public byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + T.ResumeAudioDeviceRaw(dev); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WaitConditionTimeout( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS - ) => T.WaitConditionTimeout(cond, mutex, timeoutMS); + public MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => + T.ResumeAudioStreamDevice(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WaitConditionTimeoutRaw( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS - ) => T.WaitConditionTimeoutRaw(cond, mutex, timeoutMS); + public byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => + T.ResumeAudioStreamDeviceRaw(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WaitEvent(Event* @event) => T.WaitEvent(@event); + public MaybeBool ResumeHaptic(HapticHandle haptic) => T.ResumeHaptic(haptic); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WaitEvent(Ref @event) => T.WaitEvent(@event); + public byte ResumeHapticRaw(HapticHandle haptic) => T.ResumeHapticRaw(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_round")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WaitEventTimeout(Event* @event, [NativeTypeName("Sint32")] int timeoutMS) => - T.WaitEventTimeout(@event, timeoutMS); + public double Round(double x) => T.Round(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_roundf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public float Roundf(float x) => T.Roundf(x); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WaitEventTimeout( - Ref @event, - [NativeTypeName("Sint32")] int timeoutMS - ) => T.WaitEventTimeout(@event, timeoutMS); + public MaybeBool RumbleGamepad( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleGamepad(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void WaitSemaphore(SemaphoreHandle sem) => T.WaitSemaphore(sem); + public byte RumbleGamepadRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleGamepadRaw(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WaitSemaphoreTimeout( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS - ) => T.WaitSemaphoreTimeout(sem, timeoutMS); + public MaybeBool RumbleGamepadTriggers( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WaitSemaphoreTimeoutRaw( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS - ) => T.WaitSemaphoreTimeoutRaw(sem, timeoutMS); + public byte RumbleGamepadTriggersRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleGamepadTriggersRaw(gamepad, left_rumble, right_rumble, duration_ms); - [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void WaitThread(ThreadHandle thread, int* status) => T.WaitThread(thread, status); + public MaybeBool RumbleJoystick( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleJoystick(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void WaitThread(ThreadHandle thread, Ref status) => - T.WaitThread(thread, status); + public byte RumbleJoystickRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + T.RumbleJoystickRaw(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WarpMouseGlobal(float x, float y) => T.WarpMouseGlobal(x, y); + public MaybeBool RumbleJoystickTriggers( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleJoystickTriggers(joystick, left_rumble, right_rumble, duration_ms); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WarpMouseGlobalRaw(float x, float y) => T.WarpMouseGlobalRaw(x, y); + public byte RumbleJoystickTriggersRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => T.RumbleJoystickTriggersRaw(joystick, left_rumble, right_rumble, duration_ms); - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseInWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public void WarpMouseInWindow(WindowHandle window, float x, float y) => - T.WarpMouseInWindow(window, x, y); + public int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ) => T.RunApp(argc, argv, mainFunction, reserved); - [return: NativeTypeName("SDL_InitFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => T.WasInit(flags); + public int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ) => T.RunApp(argc, argv, mainFunction, reserved); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WindowHasSurface(WindowHandle window) => T.WindowHasSurface(window); + public MaybeBool RunHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => T.RunHapticEffect(haptic, effect, iterations); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WindowHasSurfaceRaw(WindowHandle window) => T.WindowHasSurfaceRaw(window); + public byte RunHapticEffectRaw( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => T.RunHapticEffectRaw(haptic, effect, iterations); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] void* ptr, - [NativeTypeName("size_t")] nuint size - ) => T.WriteIO(context, ptr, size); + public byte SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => + T.SaveBMP(surface, file); - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] Ref ptr, - [NativeTypeName("size_t")] nuint size - ) => T.WriteIO(context, ptr, size); + public MaybeBool SaveBMP( + Ref surface, + [NativeTypeName("const char *")] Ref file + ) => T.SaveBMP(surface, file); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS16BE( + public byte SaveBMPIO( + Surface* surface, IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => T.WriteS16BE(dst, value); + [NativeTypeName("bool")] byte closeio + ) => T.SaveBMPIO(surface, dst, closeio); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS16BERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => - T.WriteS16BERaw(dst, value); + public MaybeBool SaveBMPIO( + Ref surface, + IOStreamHandle dst, + [NativeTypeName("bool")] MaybeBool closeio + ) => T.SaveBMPIO(surface, dst, closeio); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_scalbn")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS16LE( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => T.WriteS16LE(dst, value); + public double Scalbn(double x, int n) => T.Scalbn(x, n); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_scalbnf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS16LERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => - T.WriteS16LERaw(dst, value); + public float Scalbnf(float x, int n) => T.Scalbnf(x, n); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS32BE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => T.WriteS32BE(dst, value); + public Surface* ScaleSurface( + Surface* surface, + int width, + int height, + ScaleMode scaleMode + ) => T.ScaleSurface(surface, width, height, scaleMode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS32BERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => - T.WriteS32BERaw(dst, value); + public Ptr ScaleSurface( + Ref surface, + int width, + int height, + ScaleMode scaleMode + ) => T.ScaleSurface(surface, width, height, scaleMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS32LE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => T.WriteS32LE(dst, value); + public MaybeBool ScreenKeyboardShown(WindowHandle window) => + T.ScreenKeyboardShown(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS32LERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => - T.WriteS32LERaw(dst, value); + public byte ScreenKeyboardShownRaw(WindowHandle window) => T.ScreenKeyboardShownRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS64BE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => T.WriteS64BE(dst, value); + public MaybeBool ScreenSaverEnabled() => T.ScreenSaverEnabled(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS64BERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => - T.WriteS64BERaw(dst, value); + public byte ScreenSaverEnabledRaw() => T.ScreenSaverEnabledRaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS64LE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => T.WriteS64LE(dst, value); + public long SeekIO( + IOStreamHandle context, + [NativeTypeName("Sint64")] long offset, + IOWhence whence + ) => T.SeekIO(context, offset, whence); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS64LERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => - T.WriteS64LERaw(dst, value); + public byte SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] void* data, + int size + ) => T.SendGamepadEffect(gamepad, data, size); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteS8(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => - T.WriteS8(dst, value); + public MaybeBool SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] Ref data, + int size + ) => T.SendGamepadEffect(gamepad, data, size); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteS8Raw(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => - T.WriteS8Raw(dst, value); + public byte SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] void* data, + int size + ) => T.SendJoystickEffect(joystick, data, size); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const void *")] void* source, - [NativeTypeName("Uint64")] ulong length - ) => T.WriteStorageFile(storage, path, source, length); + public MaybeBool SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] Ref data, + int size + ) => T.SendJoystickEffect(joystick, data, size); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const void *")] Ref source, - [NativeTypeName("Uint64")] ulong length - ) => T.WriteStorageFile(storage, path, source, length); + public byte SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] float* data, + int num_values + ) => T.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.WriteSurfacePixel(surface, x, y, r, g, b, a); + public MaybeBool SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] Ref data, + int num_values + ) => T.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => T.WriteSurfacePixel(surface, x, y, r, g, b, a); + public byte SetAppMetadata( + [NativeTypeName("const char *")] sbyte* appname, + [NativeTypeName("const char *")] sbyte* appversion, + [NativeTypeName("const char *")] sbyte* appidentifier + ) => T.SetAppMetadata(appname, appversion, appidentifier); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteSurfacePixelFloat( - Surface* surface, - int x, - int y, - float r, - float g, - float b, - float a - ) => T.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + public MaybeBool SetAppMetadata( + [NativeTypeName("const char *")] Ref appname, + [NativeTypeName("const char *")] Ref appversion, + [NativeTypeName("const char *")] Ref appidentifier + ) => T.SetAppMetadata(appname, appversion, appidentifier); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteSurfacePixelFloat( - Ref surface, - int x, - int y, - float r, - float g, - float b, - float a - ) => T.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + public byte SetAppMetadataProperty( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => T.SetAppMetadataProperty(name, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU16BE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => T.WriteU16BE(dst, value); + public MaybeBool SetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => T.SetAppMetadataProperty(name, value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU16BERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => - T.WriteU16BERaw(dst, value); + public void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + void* userdata + ) => T.SetAssertionHandler(handler, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU16LE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => T.WriteU16LE(dst, value); + public void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + Ref userdata + ) => T.SetAssertionHandler(handler, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU16LERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => - T.WriteU16LERaw(dst, value); + public int SetAtomicInt(AtomicInt* a, int v) => T.SetAtomicInt(a, v); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU32BE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => T.WriteU32BE(dst, value); + public int SetAtomicInt(Ref a, int v) => T.SetAtomicInt(a, v); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU32BERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => - T.WriteU32BERaw(dst, value); + public void* SetAtomicPointer(void** a, void* v) => T.SetAtomicPointer(a, v); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU32LE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => T.WriteU32LE(dst, value); + public Ptr SetAtomicPointer(Ref2D a, Ref v) => T.SetAtomicPointer(a, v); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU32LERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => - T.WriteU32LERaw(dst, value); + public uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => + T.SetAtomicU32(a, v); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU64BE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => T.WriteU64BE(dst, value); + public uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) => + T.SetAtomicU32(a, v); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU64BERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => - T.WriteU64BERaw(dst, value); + public MaybeBool SetAudioDeviceGain( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => T.SetAudioDeviceGain(devid, gain); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU64LE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => T.WriteU64LE(dst, value); + public byte SetAudioDeviceGainRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => T.SetAudioDeviceGainRaw(devid, gain); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU64LERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => - T.WriteU64LERaw(dst, value); + public byte SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + void* userdata + ) => T.SetAudioPostmixCallback(devid, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public MaybeBool WriteU8(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => - T.WriteU8(dst, value); + public MaybeBool SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + Ref userdata + ) => T.SetAudioPostmixCallback(devid, callback, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public byte WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => - T.WriteU8Raw(dst, value); - } + public byte SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => T.SetAudioStreamFormat(stream, src_spec, dst_spec); - public partial class ThisThread - { - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] ulong* timestampNS - ) => Underlying.Value!.AcquireCameraFrame(camera, timestampNS); + public MaybeBool SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) => T.SetAudioStreamFormat(stream, src_spec, dst_spec); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] Ref timestampNS - ) - { - fixed (ulong* __dsl_timestampNS = timestampNS) - { - return (Surface*)AcquireCameraFrame(camera, __dsl_timestampNS); - } - } + public MaybeBool SetAudioStreamFrequencyRatio( + AudioStreamHandle stream, + float ratio + ) => T.SetAudioStreamFrequencyRatio(stream, ratio); - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddAtomicInt(AtomicInt* a, int v) => Underlying.Value!.AddAtomicInt(a, v); + public byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => + T.SetAudioStreamFrequencyRatioRaw(stream, ratio); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddAtomicInt(Ref a, int v) - { - fixed (AtomicInt* __dsl_a = a) - { - return (int)AddAtomicInt(__dsl_a, v); - } - } + public MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => + T.SetAudioStreamGain(stream, gain); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, + public byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => + T.SetAudioStreamGainRaw(stream, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public byte SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, void* userdata - ) => Underlying.Value!.AddEventWatch(filter, userdata); + ) => T.SetAudioStreamGetCallback(stream, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, + public MaybeBool SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (MaybeBool)(byte)AddEventWatch(filter, __dsl_userdata); - } - } + ) => T.SetAudioStreamGetCallback(stream, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => - Underlying.Value!.AddGamepadMapping(mapping); + public byte SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => T.SetAudioStreamInputChannelMap(stream, chmap, count); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) - { - fixed (sbyte* __dsl_mapping = mapping) - { - return (int)AddGamepadMapping(__dsl_mapping); - } - } + public MaybeBool SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) => T.SetAudioStreamInputChannelMap(stream, chmap, count); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMappingsFromFile( - [NativeTypeName("const char *")] sbyte* file - ) => Underlying.Value!.AddGamepadMappingsFromFile(file); + public byte SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => T.SetAudioStreamOutputChannelMap(stream, chmap, count); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMappingsFromFile( - [NativeTypeName("const char *")] Ref file - ) - { - fixed (sbyte* __dsl_file = file) - { - return (int)AddGamepadMappingsFromFile(__dsl_file); - } - } + public MaybeBool SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) => T.SetAudioStreamOutputChannelMap(stream, chmap, count); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio - ) => Underlying.Value!.AddGamepadMappingsFromIO(src, closeio); + public byte SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => T.SetAudioStreamPutCallback(stream, callback, userdata); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => Underlying.Value!.AddGamepadMappingsFromIO(src, closeio); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + public MaybeBool SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) => T.SetAudioStreamPutCallback(stream, callback, userdata); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte AddHintCallback( + public byte SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => Underlying.Value!.AddHintCallback(name, callback, userdata); + [NativeTypeName("bool")] byte value + ) => T.SetBooleanProperty(props, name, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool AddHintCallback( + public MaybeBool SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)AddHintCallback(__dsl_name, callback, __dsl_userdata); - } - } + [NativeTypeName("bool")] MaybeBool value + ) => T.SetBooleanProperty(props, name, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => - Underlying.Value!.AddSurfaceAlternateImage(surface, image); + public byte SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + void* userdata, + [NativeTypeName("const char **")] sbyte** mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => T.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool AddSurfaceAlternateImage( - Ref surface, - Ref image - ) - { - fixed (Surface* __dsl_image = image) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)AddSurfaceAlternateImage(__dsl_surface, __dsl_image); - } - } + public MaybeBool SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + Ref userdata, + [NativeTypeName("const char **")] Ref2D mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => T.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, - void* userdata - ) => Underlying.Value!.AddTimer(interval, callback, userdata); + public byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => + T.SetClipboardText(text); - [return: NativeTypeName("SDL_TimerID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (uint)AddTimer(interval, callback, __dsl_userdata); - } - } + public MaybeBool SetClipboardText([NativeTypeName("const char *")] Ref text) => + T.SetClipboardText(text); - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, - void* userdata - ) => Underlying.Value!.AddTimerNS(interval, callback, userdata); + public MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => + T.SetCurrentThreadPriority(priority); - [return: NativeTypeName("SDL_TimerID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (uint)AddTimerNS(interval, callback, __dsl_userdata); - } - } + public byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => + T.SetCurrentThreadPriorityRaw(priority); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool AddVulkanRenderSemaphores( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - Underlying.Value!.AddVulkanRenderSemaphores( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); + public MaybeBool SetCursor(CursorHandle cursor) => T.SetCursor(cursor); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte AddVulkanRenderSemaphoresRaw( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - Underlying.Value!.AddVulkanRenderSemaphoresRaw( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); + public byte SetCursorRaw(CursorHandle cursor) => T.SetCursorRaw(cursor); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc - ) => Underlying.Value!.AttachVirtualJoystick(desc); + public int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ) => T.SetenvUnsafe(name, value, overwrite); - [return: NativeTypeName("SDL_JoystickID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc - ) - { - fixed (VirtualJoystickDesc* __dsl_desc = desc) - { - return (uint)AttachVirtualJoystick(__dsl_desc); - } - } + public int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ) => T.SetenvUnsafe(name, value, overwrite); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool AudioDevicePaused( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => Underlying.Value!.AudioDevicePaused(dev); + public byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ) => T.SetEnvironmentVariable(env, name, value, overwrite); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - Underlying.Value!.AudioDevicePausedRaw(dev); + public MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ) => T.SetEnvironmentVariable(env, name, value, overwrite); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BindAudioStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => Underlying.Value!.BindAudioStream(devid, stream); + public byte SetErrorV( + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.SetErrorV(fmt, ap); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BindAudioStreamRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => Underlying.Value!.BindAudioStreamRaw(devid, stream); + public MaybeBool SetErrorV( + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.SetErrorV(fmt, ap); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle* streams, - int num_streams - ) => Underlying.Value!.BindAudioStreams(devid, streams, num_streams); + public void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] byte enabled + ) => T.SetEventEnabled(type, enabled); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref streams, - int num_streams - ) - { - fixed (AudioStreamHandle* __dsl_streams = streams) - { - return (MaybeBool)(byte)BindAudioStreams(devid, __dsl_streams, num_streams); - } - } + public void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] MaybeBool enabled + ) => T.SetEventEnabled(type, enabled); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurface( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => Underlying.Value!.BlitSurface(src, srcrect, dst, dstrect); + public void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => T.SetEventFilter(filter, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurface( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurface(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); - } - } + public void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => T.SetEventFilter(filter, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurface9Grid( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => - Underlying.Value!.BlitSurface9Grid( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + public byte SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float value + ) => T.SetFloatProperty(props, name, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurface9Grid( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurface9Grid( - __dsl_src, - __dsl_srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - __dsl_dst, - __dsl_dstrect - ); - } - } + public MaybeBool SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float value + ) => T.SetFloatProperty(props, name, value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurfaceScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => Underlying.Value!.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); + public void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => + T.SetGamepadEventsEnabled(enabled); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurfaceScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurfaceScaled( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect, - scaleMode - ); - } - } + public void SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + T.SetGamepadEventsEnabled(enabled); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurfaceTiled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => Underlying.Value!.BlitSurfaceTiled(src, srcrect, dst, dstrect); + public MaybeBool SetGamepadLED( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => T.SetGamepadLED(gamepad, red, green, blue); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurfaceTiled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurfaceTiled(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); - } - } + public byte SetGamepadLEDRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => T.SetGamepadLEDRaw(gamepad, red, green, blue); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurfaceTiledWithScale( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => - Underlying.Value!.BlitSurfaceTiledWithScale( - src, - srcrect, - scale, - scaleMode, - dst, - dstrect - ); + public byte SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] sbyte* mapping + ) => T.SetGamepadMapping(instance_id, mapping); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurfaceTiledWithScale( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurfaceTiledWithScale( - __dsl_src, - __dsl_srcrect, - scale, - scaleMode, - __dsl_dst, - __dsl_dstrect - ); - } - } + public MaybeBool SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] Ref mapping + ) => T.SetGamepadMapping(instance_id, mapping); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurfaceUnchecked( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => Underlying.Value!.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + public MaybeBool SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => + T.SetGamepadPlayerIndex(gamepad, player_index); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurfaceUnchecked( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurfaceUnchecked(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); - } - } + public byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => + T.SetGamepadPlayerIndexRaw(gamepad, player_index); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte BlitSurfaceUncheckedScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => Underlying.Value!.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); + public byte SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] byte enabled + ) => T.SetGamepadSensorEnabled(gamepad, type, enabled); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool BlitSurfaceUncheckedScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte)BlitSurfaceUncheckedScaled( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect, - scaleMode - ); - } - } + public MaybeBool SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] MaybeBool enabled + ) => T.SetGamepadSensorEnabled(gamepad, type, enabled); - [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBlendConstants")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void BroadcastCondition(ConditionHandle cond) => - Underlying.Value!.BroadcastCondition(cond); + public void SetGPUBlendConstants(GPURenderPassHandle render_pass, FColor blend_constants) => + T.SetGPUBlendConstants(render_pass, blend_constants); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CaptureMouse([NativeTypeName("bool")] byte enabled) => - Underlying.Value!.CaptureMouse(enabled); + public void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ) => T.SetGPUBufferName(device, buffer, text); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CaptureMouse( - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.CaptureMouse(enabled); + public void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ) => T.SetGPUBufferName(device, buffer, text); - [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CleanupTLS() => Underlying.Value!.CleanupTLS(); + public void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ) => T.SetGPUScissor(render_pass, scissor); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearAudioStream(AudioStreamHandle stream) => - Underlying.Value!.ClearAudioStream(stream); + public void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ) => T.SetGPUScissor(render_pass, scissor); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUStencilReference")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearAudioStreamRaw(AudioStreamHandle stream) => - Underlying.Value!.ClearAudioStreamRaw(stream); + public void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ) => T.SetGPUStencilReference(render_pass, reference); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearClipboardData() => - Underlying.Value!.ClearClipboardData(); + public MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => T.SetGPUSwapchainParameters(device, window, swapchain_composition, present_mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearClipboardDataRaw() => Underlying.Value!.ClearClipboardDataRaw(); + public byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => T.SetGPUSwapchainParametersRaw(device, window, swapchain_composition, present_mode); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ) => T.SetGPUTextureName(device, texture, text); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ) => T.SetGPUTextureName(device, texture, text); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ) => T.SetGPUViewport(render_pass, viewport); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ) => T.SetGPUViewport(render_pass, viewport); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearComposition(WindowHandle window) => - Underlying.Value!.ClearComposition(window); + public MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => + T.SetHapticAutocenter(haptic, autocenter); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearCompositionRaw(WindowHandle window) => - Underlying.Value!.ClearCompositionRaw(window); + public byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => + T.SetHapticAutocenterRaw(haptic, autocenter); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearError() => Underlying.Value!.ClearError(); + public MaybeBool SetHapticGain(HapticHandle haptic, int gain) => + T.SetHapticGain(haptic, gain); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearErrorRaw() => Underlying.Value!.ClearErrorRaw(); + public byte SetHapticGainRaw(HapticHandle haptic, int gain) => + T.SetHapticGainRaw(haptic, gain); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.ClearProperty(props, name); + public byte SetHint( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => T.SetHint(name, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)ClearProperty(props, __dsl_name); - } - } + public MaybeBool SetHint( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => T.SetHint(name, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ClearSurface(Surface* surface, float r, float g, float b, float a) => - Underlying.Value!.ClearSurface(surface, r, g, b, a); + public byte SetHintWithPriority( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + HintPriority priority + ) => T.SetHintWithPriority(name, value, priority); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ClearSurface( - Ref surface, - float r, - float g, - float b, - float a - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)ClearSurface(__dsl_surface, r, g, b, a); - } - } + public MaybeBool SetHintWithPriority( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + HintPriority priority + ) => T.SetHintWithPriority(name, value, priority); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - Underlying.Value!.CloseAudioDevice(devid); + public void SetInitialized(InitState* state, [NativeTypeName("bool")] byte initialized) => + T.SetInitialized(state, initialized); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseCamera(CameraHandle camera) => - Underlying.Value!.CloseCamera(camera); + public void SetInitialized( + Ref state, + [NativeTypeName("bool")] MaybeBool initialized + ) => T.SetInitialized(state, initialized); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseGamepad(GamepadHandle gamepad) => - Underlying.Value!.CloseGamepad(gamepad); + public void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => + T.SetJoystickEventsEnabled(enabled); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseHaptic(HapticHandle haptic) => - Underlying.Value!.CloseHaptic(haptic); + public void SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + T.SetJoystickEventsEnabled(enabled); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CloseIO(IOStreamHandle context) => - Underlying.Value!.CloseIO(context); + public MaybeBool SetJoystickLED( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => T.SetJoystickLED(joystick, red, green, blue); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CloseIORaw(IOStreamHandle context) => - Underlying.Value!.CloseIORaw(context); + public byte SetJoystickLEDRaw( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => T.SetJoystickLEDRaw(joystick, red, green, blue); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseJoystick(JoystickHandle joystick) => - Underlying.Value!.CloseJoystick(joystick); + public MaybeBool SetJoystickPlayerIndex(JoystickHandle joystick, int player_index) => + T.SetJoystickPlayerIndex(joystick, player_index); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void CloseSensor(SensorHandle sensor) => - Underlying.Value!.CloseSensor(sensor); + public byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => + T.SetJoystickPlayerIndexRaw(joystick, player_index); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CloseStorage(StorageHandle storage) => - Underlying.Value!.CloseStorage(storage); + public MaybeBool SetJoystickVirtualAxis( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => T.SetJoystickVirtualAxis(joystick, axis, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CloseStorageRaw(StorageHandle storage) => - Underlying.Value!.CloseStorageRaw(storage); + public byte SetJoystickVirtualAxisRaw( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => T.SetJoystickVirtualAxisRaw(joystick, axis, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => - Underlying.Value!.CompareAndSwapAtomicInt(a, oldval, newval); + public MaybeBool SetJoystickVirtualBall( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => T.SetJoystickVirtualBall(joystick, ball, xrel, yrel); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CompareAndSwapAtomicInt( - Ref a, - int oldval, - int newval - ) - { - fixed (AtomicInt* __dsl_a = a) - { - return (MaybeBool)(byte)CompareAndSwapAtomicInt(__dsl_a, oldval, newval); - } - } + public byte SetJoystickVirtualBallRaw( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => T.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => - Underlying.Value!.CompareAndSwapAtomicPointer(a, oldval, newval); + public byte SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] byte down + ) => T.SetJoystickVirtualButton(joystick, button, down); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) - { - fixed (void* __dsl_newval = newval) - fixed (void* __dsl_oldval = oldval) - fixed (void** __dsl_a = a) - { - return (MaybeBool) - (byte)CompareAndSwapAtomicPointer(__dsl_a, __dsl_oldval, __dsl_newval); - } - } + public MaybeBool SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] MaybeBool down + ) => T.SetJoystickVirtualButton(joystick, button, down); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CompareAndSwapAtomicU32( - AtomicU32* a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => Underlying.Value!.CompareAndSwapAtomicU32(a, oldval, newval); + public MaybeBool SetJoystickVirtualHat( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => T.SetJoystickVirtualHat(joystick, hat, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CompareAndSwapAtomicU32( - Ref a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) - { - fixed (AtomicU32* __dsl_a = a) - { - return (MaybeBool)(byte)CompareAndSwapAtomicU32(__dsl_a, oldval, newval); - } - } + public byte SetJoystickVirtualHatRaw( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => T.SetJoystickVirtualHatRaw(joystick, hat, value); - [return: NativeTypeName("SDL_BlendMode")] - [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint ComposeCustomBlendMode( - BlendFactor srcColorFactor, - BlendFactor dstColorFactor, - BlendOperation colorOperation, - BlendFactor srcAlphaFactor, - BlendFactor dstAlphaFactor, - BlendOperation alphaOperation - ) => - Underlying.Value!.ComposeCustomBlendMode( - srcColorFactor, - dstColorFactor, - colorOperation, - srcAlphaFactor, - dstAlphaFactor, - alphaOperation - ); + public byte SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] byte down, + float x, + float y, + float pressure + ) => T.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const Uint8 *")] byte* src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, - [NativeTypeName("Uint8 **")] byte** dst_data, - int* dst_len - ) => - Underlying.Value!.ConvertAudioSamples( - src_spec, - src_data, - src_len, - dst_spec, - dst_data, - dst_len - ); + public MaybeBool SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] MaybeBool down, + float x, + float y, + float pressure + ) => T.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, + void* userdata + ) => T.SetLogOutputFunction(callback, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const Uint8 *")] Ref src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, - [NativeTypeName("Uint8 **")] Ref2D dst_data, - Ref dst_len - ) - { - fixed (int* __dsl_dst_len = dst_len) - fixed (byte** __dsl_dst_data = dst_data) - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (byte* __dsl_src_data = src_data) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (MaybeBool) - (byte)ConvertAudioSamples( - __dsl_src_spec, - __dsl_src_data, - src_len, - __dsl_dst_spec, - __dsl_dst_data, - __dsl_dst_len - ); - } - } + public void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, + Ref userdata + ) => T.SetLogOutputFunction(callback, userdata); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetLogPriorities(LogPriority priority) => T.SetLogPriorities(priority); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void SetLogPriority(int category, LogPriority priority) => + T.SetLogPriority(category, priority); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ConvertEventToRenderCoordinates( - RendererHandle renderer, - Event* @event - ) => Underlying.Value!.ConvertEventToRenderCoordinates(renderer, @event); + public byte SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] sbyte* prefix + ) => T.SetLogPriorityPrefix(priority, prefix); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ConvertEventToRenderCoordinates( - RendererHandle renderer, - Ref @event - ) - { - fixed (Event* __dsl_event = @event) - { - return (MaybeBool) - (byte)ConvertEventToRenderCoordinates(renderer, __dsl_event); - } - } + public MaybeBool SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] Ref prefix + ) => T.SetLogPriorityPrefix(priority, prefix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMainReady")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch - ) => - Underlying.Value!.ConvertPixels( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch - ); + public void SetMainReady() => T.SetMainReady(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch - ) - { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) - { - return (MaybeBool) - (byte)ConvertPixels( - width, - height, - src_format, - __dsl_src, - src_pitch, - dst_format, - __dsl_dst, - dst_pitch - ); - } - } + public MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => T.SetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - void* dst, - int dst_pitch - ) => - Underlying.Value!.ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + public byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => T.SetMemoryFunctionsRaw(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - Ref dst, - int dst_pitch - ) - { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) - { - return (MaybeBool) - (byte)ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - __dsl_src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - __dsl_dst, - dst_pitch - ); - } - } + public void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => + T.SetModState(modstate); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* ConvertSurface(Surface* surface, PixelFormat format) => - Underlying.Value!.ConvertSurface(surface, format); + public byte SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long value + ) => T.SetNumberProperty(props, name, value); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr ConvertSurface(Ref surface, PixelFormat format) - { - fixed (Surface* __dsl_surface = surface) - { - return (Surface*)ConvertSurface(__dsl_surface, format); - } - } + public MaybeBool SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long value + ) => T.SetNumberProperty(props, name, value); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* ConvertSurfaceAndColorspace( - Surface* surface, - PixelFormat format, + public byte SetPaletteColors( Palette* palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => - Underlying.Value!.ConvertSurfaceAndColorspace( - surface, - format, - palette, - colorspace, - props - ); + [NativeTypeName("const SDL_Color *")] Color* colors, + int firstcolor, + int ncolors + ) => T.SetPaletteColors(palette, colors, firstcolor, ncolors); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr ConvertSurfaceAndColorspace( - Ref surface, - PixelFormat format, + public MaybeBool SetPaletteColors( Ref palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) - { - fixed (Palette* __dsl_palette = palette) - fixed (Surface* __dsl_surface = surface) - { - return (Surface*)ConvertSurfaceAndColorspace( - __dsl_surface, - format, - __dsl_palette, - colorspace, - props - ); - } - } + [NativeTypeName("const SDL_Color *")] Ref colors, + int firstcolor, + int ncolors + ) => T.SetPaletteColors(palette, colors, firstcolor, ncolors); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CopyFile( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => Underlying.Value!.CopyFile(oldpath, newpath); + public byte SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value + ) => T.SetPointerProperty(props, name, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CopyFile( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool)(byte)CopyFile(__dsl_oldpath, __dsl_newpath); - } - } + public MaybeBool SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value + ) => T.SetPointerProperty(props, name, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CopyProperties( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => Underlying.Value!.CopyProperties(src, dst); + public byte SetPointerPropertyWithCleanup( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + void* userdata + ) => T.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CopyPropertiesRaw( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => Underlying.Value!.CopyPropertiesRaw(src, dst); + public MaybeBool SetPointerPropertyWithCleanup( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + Ref userdata + ) => T.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => Underlying.Value!.CopyStorageFile(storage, oldpath, newpath); + public byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => + T.SetPrimarySelectionText(text); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool) - (byte)CopyStorageFile(storage, __dsl_oldpath, __dsl_newpath); - } - } + public MaybeBool SetPrimarySelectionText( + [NativeTypeName("const char *")] Ref text + ) => T.SetPrimarySelectionText(text); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => Underlying.Value!.CreateAudioStream(src_spec, dst_spec); + public byte SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => T.SetRenderClipRect(renderer, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) - { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (AudioStreamHandle)CreateAudioStream(__dsl_src_spec, __dsl_dst_spec); - } - } + public MaybeBool SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => T.SetRenderClipRect(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => - Underlying.Value!.CreateColorCursor(surface, hot_x, hot_y); + public MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => + T.SetRenderColorScale(renderer, scale); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) - { - fixed (Surface* __dsl_surface = surface) - { - return (CursorHandle)CreateColorCursor(__dsl_surface, hot_x, hot_y); - } - } + public byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => + T.SetRenderColorScaleRaw(renderer, scale); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ConditionHandle CreateCondition() => Underlying.Value!.CreateCondition(); + public MaybeBool SetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetRenderDrawBlendMode(renderer, blendMode); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] byte* data, - [NativeTypeName("const Uint8 *")] byte* mask, - int w, - int h, - int hot_x, - int hot_y - ) => Underlying.Value!.CreateCursor(data, mask, w, h, hot_x, hot_y); + public byte SetRenderDrawBlendModeRaw( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetRenderDrawBlendModeRaw(renderer, blendMode); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] Ref data, - [NativeTypeName("const Uint8 *")] Ref mask, - int w, - int h, - int hot_x, - int hot_y - ) - { - fixed (byte* __dsl_mask = mask) - fixed (byte* __dsl_data = data) - { - return (CursorHandle)CreateCursor(__dsl_data, __dsl_mask, w, h, hot_x, hot_y); - } - } + public MaybeBool SetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.SetRenderDrawColor(renderer, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => - Underlying.Value!.CreateDirectory(path); + public MaybeBool SetRenderDrawColorFloat( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => T.SetRenderDrawColorFloat(renderer, r, g, b, a); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CreateDirectory( - [NativeTypeName("const char *")] Ref path - ) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)CreateDirectory(__dsl_path); - } - } + public byte SetRenderDrawColorFloatRaw( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => T.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => Underlying.Value!.CreateHapticEffect(haptic, effect); + public byte SetRenderDrawColorRaw( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.SetRenderDrawColorRaw(renderer, r, g, b, a); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) - { - fixed (HapticEffect* __dsl_effect = effect) - { - return (int)CreateHapticEffect(haptic, __dsl_effect); - } - } + public MaybeBool SetRenderLogicalPresentation( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => T.SetRenderLogicalPresentation(renderer, w, h, mode); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MutexHandle CreateMutex() => Underlying.Value!.CreateMutex(); + public byte SetRenderLogicalPresentationRaw( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => T.SetRenderLogicalPresentationRaw(renderer, w, h, mode); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreatePalette(int ncolors) => - Underlying.Value!.CreatePalette(ncolors); + public MaybeBool SetRenderScale( + RendererHandle renderer, + float scaleX, + float scaleY + ) => T.SetRenderScale(renderer, scaleX, scaleY); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Palette* CreatePaletteRaw(int ncolors) => - Underlying.Value!.CreatePaletteRaw(ncolors); + public byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => + T.SetRenderScaleRaw(renderer, scaleX, scaleY); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle CreatePopupWindow( - WindowHandle parent, - int offset_x, - int offset_y, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => Underlying.Value!.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); + public byte SetRenderTarget(RendererHandle renderer, Texture* texture) => + T.SetRenderTarget(renderer, texture); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint CreateProperties() => Underlying.Value!.CreateProperties(); + public MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) => + T.SetRenderTarget(renderer, texture); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.CreateRenderer(window, name); + public byte SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => T.SetRenderViewport(renderer, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (RendererHandle)CreateRenderer(window, __dsl_name); - } - } + public MaybeBool SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => T.SetRenderViewport(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle CreateRendererWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.CreateRendererWithProperties(props); + public MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => + T.SetRenderVSync(renderer, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RWLockHandle CreateRWLock() => Underlying.Value!.CreateRWLock(); + public byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => + T.SetRenderVSyncRaw(renderer, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SemaphoreHandle CreateSemaphore( - [NativeTypeName("Uint32")] uint initial_value - ) => Underlying.Value!.CreateSemaphore(initial_value); + public byte SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] sbyte* name + ) => T.SetScancodeName(scancode, name); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle CreateSoftwareRenderer(Surface* surface) => - Underlying.Value!.CreateSoftwareRenderer(surface); + public MaybeBool SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] Ref name + ) => T.SetScancodeName(scancode, name); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle CreateSoftwareRenderer(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (RendererHandle)CreateSoftwareRenderer(__dsl_surface); - } - } + public byte SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => T.SetStringProperty(props, name, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => Underlying.Value!.CreateStorageDirectory(storage, path); + public MaybeBool SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => T.SetStringProperty(props, name, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)CreateStorageDirectory(storage, __dsl_path); - } - } + public byte SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => + T.SetSurfaceAlphaMod(surface, alpha); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreateSurface(int width, int height, PixelFormat format) => - Underlying.Value!.CreateSurface(width, height, format); + public MaybeBool SetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8")] byte alpha + ) => T.SetSurfaceAlphaMod(surface, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - void* pixels, - int pitch - ) => Underlying.Value!.CreateSurfaceFrom(width, height, format, pixels, pitch); + public byte SetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetSurfaceBlendMode(surface, blendMode); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - Ref pixels, - int pitch - ) - { - fixed (void* __dsl_pixels = pixels) - { - return (Surface*)CreateSurfaceFrom(width, height, format, __dsl_pixels, pitch); - } - } + public MaybeBool SetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetSurfaceBlendMode(surface, blendMode); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Palette* CreateSurfacePalette(Surface* surface) => - Underlying.Value!.CreateSurfacePalette(surface); + public byte SetSurfaceClipRect( + Surface* surface, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => T.SetSurfaceClipRect(surface, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr CreateSurfacePalette(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (Palette*)CreateSurfacePalette(__dsl_surface); - } - } - - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => - Underlying.Value!.CreateSurfaceRaw(width, height, format); + public MaybeBool SetSurfaceClipRect( + Ref surface, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => T.SetSurfaceClipRect(surface, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle CreateSystemCursor(SystemCursor id) => - Underlying.Value!.CreateSystemCursor(id); + public byte SetSurfaceColorKey( + Surface* surface, + [NativeTypeName("bool")] byte enabled, + [NativeTypeName("Uint32")] uint key + ) => T.SetSurfaceColorKey(surface, enabled, key); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreateTexture( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => Underlying.Value!.CreateTexture(renderer, format, access, w, h); + public MaybeBool SetSurfaceColorKey( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled, + [NativeTypeName("Uint32")] uint key + ) => T.SetSurfaceColorKey(surface, enabled, key); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Texture* CreateTextureFromSurface( - RendererHandle renderer, - Surface* surface - ) => Underlying.Value!.CreateTextureFromSurface(renderer, surface); + public byte SetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.SetSurfaceColorMod(surface, r, g, b); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreateTextureFromSurface( - RendererHandle renderer, - Ref surface - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (Texture*)CreateTextureFromSurface(renderer, __dsl_surface); - } - } + public MaybeBool SetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.SetSurfaceColorMod(surface, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Texture* CreateTextureRaw( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => Underlying.Value!.CreateTextureRaw(renderer, format, access, w, h); + public byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => + T.SetSurfaceColorspace(surface, colorspace); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr CreateTextureWithProperties( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.CreateTextureWithProperties(renderer, props); + public MaybeBool SetSurfaceColorspace(Ref surface, Colorspace colorspace) => + T.SetSurfaceColorspace(surface, colorspace); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Texture* CreateTextureWithPropertiesRaw( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.CreateTextureWithPropertiesRaw(renderer, props); + public byte SetSurfacePalette(Surface* surface, Palette* palette) => + T.SetSurfacePalette(surface, palette); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] sbyte* name, - void* data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => Underlying.Value!.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); + public MaybeBool SetSurfacePalette(Ref surface, Ref palette) => + T.SetSurfacePalette(surface, palette); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] Ref name, - Ref data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) - { - fixed (void* __dsl_data = data) - fixed (sbyte* __dsl_name = name) - { - return (ThreadHandle)CreateThreadRuntime( - fn, - __dsl_name, - __dsl_data, - pfnBeginThread, - pfnEndThread - ); - } - } + public byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => + T.SetSurfaceRLE(surface, enabled); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ThreadHandle CreateThreadWithPropertiesRuntime( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => - Underlying.Value!.CreateThreadWithPropertiesRuntime( - props, - pfnBeginThread, - pfnEndThread - ); + public MaybeBool SetSurfaceRLE( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled + ) => T.SetSurfaceRLE(surface, enabled); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle CreateWindow( - [NativeTypeName("const char *")] sbyte* title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => Underlying.Value!.CreateWindow(title, w, h, flags); + public byte SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int cursor + ) => T.SetTextInputArea(window, rect, cursor); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle CreateWindow( - [NativeTypeName("const char *")] Ref title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) - { - fixed (sbyte* __dsl_title = title) - { - return (WindowHandle)CreateWindow(__dsl_title, w, h, flags); - } - } + public MaybeBool SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect, + int cursor + ) => T.SetTextInputArea(window, rect, cursor); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CreateWindowAndRenderer( - [NativeTypeName("const char *")] sbyte* title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - WindowHandle* window, - RendererHandle* renderer - ) => - Underlying.Value!.CreateWindowAndRenderer( - title, - width, - height, - window_flags, - window, - renderer - ); + public byte SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => + T.SetTextureAlphaMod(texture, alpha); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CreateWindowAndRenderer( - [NativeTypeName("const char *")] Ref title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - Ref window, - Ref renderer - ) - { - fixed (RendererHandle* __dsl_renderer = renderer) - fixed (WindowHandle* __dsl_window = window) - fixed (sbyte* __dsl_title = title) - { - return (MaybeBool) - (byte)CreateWindowAndRenderer( - __dsl_title, - width, - height, - window_flags, - __dsl_window, - __dsl_renderer - ); - } - } + public MaybeBool SetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8")] byte alpha + ) => T.SetTextureAlphaMod(texture, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle CreateWindowWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.CreateWindowWithProperties(props); + public byte SetTextureAlphaModFloat(Texture* texture, float alpha) => + T.SetTextureAlphaModFloat(texture, alpha); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool CursorVisible() => Underlying.Value!.CursorVisible(); + public MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) => + T.SetTextureAlphaModFloat(texture, alpha); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte CursorVisibleRaw() => Underlying.Value!.CursorVisibleRaw(); + public byte SetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetTextureBlendMode(texture, blendMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] DateTime* dt, - [NativeTypeName("SDL_Time *")] long* ticks - ) => Underlying.Value!.DateTimeToTime(dt, ticks); + public MaybeBool SetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => T.SetTextureBlendMode(texture, blendMode); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] Ref dt, - [NativeTypeName("SDL_Time *")] Ref ticks - ) - { - fixed (long* __dsl_ticks = ticks) - fixed (DateTime* __dsl_dt = dt) - { - return (MaybeBool)(byte)DateTimeToTime(__dsl_dt, __dsl_ticks); - } - } + public byte SetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.SetTextureColorMod(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void Delay([NativeTypeName("Uint32")] uint ms) => Underlying.Value!.Delay(ms); + public MaybeBool SetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => T.SetTextureColorMod(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DelayNS([NativeTypeName("Uint64")] ulong ns) => - Underlying.Value!.DelayNS(ns); + public byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => + T.SetTextureColorModFloat(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => - Underlying.Value!.DelayPrecise(ns); + public MaybeBool SetTextureColorModFloat( + Ref texture, + float r, + float g, + float b + ) => T.SetTextureColorModFloat(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyAudioStream(AudioStreamHandle stream) => - Underlying.Value!.DestroyAudioStream(stream); + public byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => + T.SetTextureScaleMode(texture, scaleMode); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyCondition(ConditionHandle cond) => - Underlying.Value!.DestroyCondition(cond); + public MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) => + T.SetTextureScaleMode(texture, scaleMode); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyCursor(CursorHandle cursor) => - Underlying.Value!.DestroyCursor(cursor); + public byte SetTLS( + [NativeTypeName("SDL_TLSID *")] AtomicInt* id, + [NativeTypeName("const void *")] void* value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) => T.SetTLS(id, value, destructor); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyHapticEffect(HapticHandle haptic, int effect) => - Underlying.Value!.DestroyHapticEffect(haptic, effect); + public MaybeBool SetTLS( + [NativeTypeName("SDL_TLSID *")] Ref id, + [NativeTypeName("const void *")] Ref value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) => T.SetTLS(id, value, destructor); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyMutex(MutexHandle mutex) => Underlying.Value!.DestroyMutex(mutex); + public byte SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] byte on_top + ) => T.SetWindowAlwaysOnTop(window, on_top); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyPalette(Palette* palette) => - Underlying.Value!.DestroyPalette(palette); + public MaybeBool SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool on_top + ) => T.SetWindowAlwaysOnTop(window, on_top); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyPalette(Ref palette) - { - fixed (Palette* __dsl_palette = palette) - { - DestroyPalette(__dsl_palette); - } - } + public MaybeBool SetWindowAspectRatio( + WindowHandle window, + float min_aspect, + float max_aspect + ) => T.SetWindowAspectRatio(window, min_aspect, max_aspect); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - Underlying.Value!.DestroyProperties(props); + public byte SetWindowAspectRatioRaw( + WindowHandle window, + float min_aspect, + float max_aspect + ) => T.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void DestroyRenderer(RendererHandle renderer) => - Underlying.Value!.DestroyRenderer(renderer); - - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyRWLock(RWLockHandle rwlock) => - Underlying.Value!.DestroyRWLock(rwlock); + public byte SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] byte bordered + ) => T.SetWindowBordered(window, bordered); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroySemaphore(SemaphoreHandle sem) => - Underlying.Value!.DestroySemaphore(sem); + public MaybeBool SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool bordered + ) => T.SetWindowBordered(window, bordered); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroySurface(Surface* surface) => - Underlying.Value!.DestroySurface(surface); + public byte SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] byte focusable + ) => T.SetWindowFocusable(window, focusable); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroySurface(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - DestroySurface(__dsl_surface); - } - } + public MaybeBool SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool focusable + ) => T.SetWindowFocusable(window, focusable); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyTexture(Texture* texture) => - Underlying.Value!.DestroyTexture(texture); + public byte SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] byte fullscreen + ) => T.SetWindowFullscreen(window, fullscreen); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyTexture(Ref texture) - { - fixed (Texture* __dsl_texture = texture) - { - DestroyTexture(__dsl_texture); - } - } + public MaybeBool SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool fullscreen + ) => T.SetWindowFullscreen(window, fullscreen); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DestroyWindow(WindowHandle window) => - Underlying.Value!.DestroyWindow(window); + public byte SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode + ) => T.SetWindowFullscreenMode(window, mode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool DestroyWindowSurface(WindowHandle window) => - Underlying.Value!.DestroyWindowSurface(window); + public MaybeBool SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] Ref mode + ) => T.SetWindowFullscreenMode(window, mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte DestroyWindowSurfaceRaw(WindowHandle window) => - Underlying.Value!.DestroyWindowSurfaceRaw(window); - - [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void DetachThread(ThreadHandle thread) => - Underlying.Value!.DetachThread(thread); + public byte SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + void* callback_data + ) => T.SetWindowHitTest(window, callback, callback_data); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool DetachVirtualJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.DetachVirtualJoystick(instance_id); + public MaybeBool SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + Ref callback_data + ) => T.SetWindowHitTest(window, callback, callback_data); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte DetachVirtualJoystickRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.DetachVirtualJoystickRaw(instance_id); + public byte SetWindowIcon(WindowHandle window, Surface* icon) => + T.SetWindowIcon(window, icon); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool DisableScreenSaver() => - Underlying.Value!.DisableScreenSaver(); + public MaybeBool SetWindowIcon(WindowHandle window, Ref icon) => + T.SetWindowIcon(window, icon); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte DisableScreenSaverRaw() => Underlying.Value!.DisableScreenSaverRaw(); + public byte SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => T.SetWindowKeyboardGrab(window, grabbed); - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* DuplicateSurface(Surface* surface) => - Underlying.Value!.DuplicateSurface(surface); + public MaybeBool SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => T.SetWindowKeyboardGrab(window, grabbed); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr DuplicateSurface(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (Surface*)DuplicateSurface(__dsl_surface); - } - } + public MaybeBool SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => + T.SetWindowMaximumSize(window, max_w, max_h); - [return: NativeTypeName("SDL_EGLConfig")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr EGLGetCurrentConfig() => Underlying.Value!.EGLGetCurrentConfig(); + public byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => + T.SetWindowMaximumSizeRaw(window, max_w, max_h); - [return: NativeTypeName("SDL_EGLConfig")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* EGLGetCurrentConfigRaw() => Underlying.Value!.EGLGetCurrentConfigRaw(); + public MaybeBool SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => + T.SetWindowMinimumSize(window, min_w, min_h); - [return: NativeTypeName("SDL_EGLDisplay")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr EGLGetCurrentDisplay() => Underlying.Value!.EGLGetCurrentDisplay(); + public byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => + T.SetWindowMinimumSizeRaw(window, min_w, min_h); - [return: NativeTypeName("SDL_EGLDisplay")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* EGLGetCurrentDisplayRaw() => - Underlying.Value!.EGLGetCurrentDisplayRaw(); + public byte SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => + T.SetWindowModal(window, modal); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer EGLGetProcAddress( - [NativeTypeName("const char *")] sbyte* proc - ) => Underlying.Value!.EGLGetProcAddress(proc); + public MaybeBool SetWindowModal( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool modal + ) => T.SetWindowModal(window, modal); - [return: NativeTypeName("SDL_FunctionPointer")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer EGLGetProcAddress( - [NativeTypeName("const char *")] Ref proc - ) - { - fixed (sbyte* __dsl_proc = proc) - { - return (FunctionPointer)EGLGetProcAddress(__dsl_proc); - } - } + public byte SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => T.SetWindowMouseGrab(window, grabbed); - [return: NativeTypeName("SDL_EGLSurface")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr EGLGetWindowSurface(WindowHandle window) => - Underlying.Value!.EGLGetWindowSurface(window); + public MaybeBool SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => T.SetWindowMouseGrab(window, grabbed); - [return: NativeTypeName("SDL_EGLSurface")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* EGLGetWindowSurfaceRaw(WindowHandle window) => - Underlying.Value!.EGLGetWindowSurfaceRaw(window); + public byte SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => T.SetWindowMouseRect(window, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - void* userdata - ) => - Underlying.Value!.EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - userdata - ); + public MaybeBool SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => T.SetWindowMouseRect(window, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - __dsl_userdata - ); - } - } + public MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => + T.SetWindowOpacity(window, opacity); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool EnableScreenSaver() => Underlying.Value!.EnableScreenSaver(); + public byte SetWindowOpacityRaw(WindowHandle window, float opacity) => + T.SetWindowOpacityRaw(window, opacity); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte EnableScreenSaverRaw() => Underlying.Value!.EnableScreenSaverRaw(); + public MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => + T.SetWindowParent(window, parent); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte EnumerateDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => Underlying.Value!.EnumerateDirectory(path, callback, userdata); + public byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => + T.SetWindowParentRaw(window, parent); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool EnumerateDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)EnumerateDirectory(__dsl_path, callback, __dsl_userdata); - } - } + public MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => + T.SetWindowPosition(window, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] - EnumeratePropertiesCallback callback, - void* userdata - ) => Underlying.Value!.EnumerateProperties(props, callback, userdata); + public byte SetWindowPositionRaw(WindowHandle window, int x, int y) => + T.SetWindowPositionRaw(window, x, y); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] - EnumeratePropertiesCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (MaybeBool)(byte)EnumerateProperties(props, callback, __dsl_userdata); - } - } + public byte SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] byte enabled + ) => T.SetWindowRelativeMouseMode(window, enabled); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => Underlying.Value!.EnumerateStorageDirectory(storage, path, callback, userdata); + public MaybeBool SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool enabled + ) => T.SetWindowRelativeMouseMode(window, enabled); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)EnumerateStorageDirectory(storage, __dsl_path, callback, __dsl_userdata); - } - } + public byte SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] byte resizable + ) => T.SetWindowResizable(window, resizable); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => - Underlying.Value!.EventEnabled(type); + public MaybeBool SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool resizable + ) => T.SetWindowResizable(window, resizable); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => - Underlying.Value!.EventEnabledRaw(type); + public byte SetWindowShape(WindowHandle window, Surface* shape) => + T.SetWindowShape(window, shape); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FillSurfaceRect( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("Uint32")] uint color - ) => Underlying.Value!.FillSurfaceRect(dst, rect, color); + public MaybeBool SetWindowShape(WindowHandle window, Ref shape) => + T.SetWindowShape(window, shape); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FillSurfaceRect( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("Uint32")] uint color - ) - { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_dst = dst) - { - return (MaybeBool)(byte)FillSurfaceRect(__dsl_dst, __dsl_rect, color); - } - } + public MaybeBool SetWindowSize(WindowHandle window, int w, int h) => + T.SetWindowSize(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FillSurfaceRects( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => Underlying.Value!.FillSurfaceRects(dst, rects, count, color); + public byte SetWindowSizeRaw(WindowHandle window, int w, int h) => + T.SetWindowSizeRaw(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FillSurfaceRects( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int count, - [NativeTypeName("Uint32")] uint color - ) - { - fixed (Rect* __dsl_rects = rects) - fixed (Surface* __dsl_dst = dst) - { - return (MaybeBool) - (byte)FillSurfaceRects(__dsl_dst, __dsl_rects, count, color); - } - } + public MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => + T.SetWindowSurfaceVSync(window, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => Underlying.Value!.FilterEvents(filter, userdata); + public byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => + T.SetWindowSurfaceVSyncRaw(window, vsync); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - FilterEvents(filter, __dsl_userdata); - } - } + public byte SetWindowTitle( + WindowHandle window, + [NativeTypeName("const char *")] sbyte* title + ) => T.SetWindowTitle(window, title); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => - Underlying.Value!.FlashWindow(window, operation); + public MaybeBool SetWindowTitle( + WindowHandle window, + [NativeTypeName("const char *")] Ref title + ) => T.SetWindowTitle(window, title); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => - Underlying.Value!.FlashWindowRaw(window, operation); + public byte ShouldInit(InitState* state) => T.ShouldInit(state); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FlipSurface(Surface* surface, FlipMode flip) => - Underlying.Value!.FlipSurface(surface, flip); + public MaybeBool ShouldInit(Ref state) => T.ShouldInit(state); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FlipSurface(Ref surface, FlipMode flip) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)FlipSurface(__dsl_surface, flip); - } - } + public byte ShouldQuit(InitState* state) => T.ShouldQuit(state); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FlushAudioStream(AudioStreamHandle stream) => - Underlying.Value!.FlushAudioStream(stream); + public MaybeBool ShouldQuit(Ref state) => T.ShouldQuit(state); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FlushAudioStreamRaw(AudioStreamHandle stream) => - Underlying.Value!.FlushAudioStreamRaw(stream); + public MaybeBool ShowCursor() => T.ShowCursor(); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void FlushEvent([NativeTypeName("Uint32")] uint type) => - Underlying.Value!.FlushEvent(type); + public byte ShowCursorRaw() => T.ShowCursorRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void FlushEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => Underlying.Value!.FlushEvents(minType, maxType); + public byte ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, + int* buttonid + ) => T.ShowMessageBox(messageboxdata, buttonid); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FlushIO(IOStreamHandle context) => - Underlying.Value!.FlushIO(context); + public MaybeBool ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, + Ref buttonid + ) => T.ShowMessageBox(messageboxdata, buttonid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FlushIORaw(IOStreamHandle context) => - Underlying.Value!.FlushIORaw(context); + public void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => + T.ShowOpenFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location, + allow_many + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool FlushRenderer(RendererHandle renderer) => - Underlying.Value!.FlushRenderer(renderer); + public void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) => + T.ShowOpenFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location, + allow_many + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte FlushRendererRaw(RendererHandle renderer) => - Underlying.Value!.FlushRendererRaw(renderer); + public void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => T.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GamepadConnected(GamepadHandle gamepad) => - Underlying.Value!.GamepadConnected(gamepad); + public void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) => T.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadConnectedRaw(GamepadHandle gamepad) => - Underlying.Value!.GamepadConnectedRaw(gamepad); + public void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location + ) => T.ShowSaveFileDialog(callback, userdata, window, filters, nfilters, default_location); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GamepadEventsEnabled() => - Underlying.Value!.GamepadEventsEnabled(); + public void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location + ) => T.ShowSaveFileDialog(callback, userdata, window, filters, nfilters, default_location); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadEventsEnabledRaw() => Underlying.Value!.GamepadEventsEnabledRaw(); + public byte ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] sbyte* title, + [NativeTypeName("const char *")] sbyte* message, + WindowHandle window + ) => T.ShowSimpleMessageBox(flags, title, message, window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => - Underlying.Value!.GamepadHasAxis(gamepad, axis); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => - Underlying.Value!.GamepadHasAxisRaw(gamepad, axis); + public MaybeBool ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] Ref title, + [NativeTypeName("const char *")] Ref message, + WindowHandle window + ) => T.ShowSimpleMessageBox(flags, title, message, window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GamepadHasButton( - GamepadHandle gamepad, - GamepadButton button - ) => Underlying.Value!.GamepadHasButton(gamepad, button); + public MaybeBool ShowWindow(WindowHandle window) => T.ShowWindow(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => - Underlying.Value!.GamepadHasButtonRaw(gamepad, button); + public byte ShowWindowRaw(WindowHandle window) => T.ShowWindowRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => - Underlying.Value!.GamepadHasSensor(gamepad, type); + public MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => + T.ShowWindowSystemMenu(window, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => - Underlying.Value!.GamepadHasSensorRaw(gamepad, type); + public byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => + T.ShowWindowSystemMenuRaw(window, x, y); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type - ) => Underlying.Value!.GamepadSensorEnabled(gamepad, type); + public void SignalCondition(ConditionHandle cond) => T.SignalCondition(cond); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => - Underlying.Value!.GamepadSensorEnabledRaw(gamepad, type); + public void SignalSemaphore(SemaphoreHandle sem) => T.SignalSemaphore(sem); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_sin")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => - Underlying.Value!.GetAppMetadataProperty(name); + public double Sin(double x) => T.Sin(x); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_sinf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (sbyte*)GetAppMetadataProperty(__dsl_name); - } - } + public float Sinf(float x) => T.Sinf(x); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_sqrt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertionHandler GetAssertionHandler(void** puserdata) => - Underlying.Value!.GetAssertionHandler(puserdata); + public double Sqrt(double x) => T.Sqrt(x); - [return: NativeTypeName("SDL_AssertionHandler")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_sqrtf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertionHandler GetAssertionHandler(Ref2D puserdata) - { - fixed (void** __dsl_puserdata = puserdata) - { - return (AssertionHandler)GetAssertionHandler(__dsl_puserdata); - } - } + public float Sqrtf(float x) => T.Sqrtf(x); - [return: NativeTypeName("const SDL_AssertData *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [NativeFunction("SDL3", EntryPoint = "SDL_srand")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAssertionReport() => - Underlying.Value!.GetAssertionReport(); + public void Srand([NativeTypeName("Uint64")] ulong seed) => T.Srand(seed); - [return: NativeTypeName("const SDL_AssertData *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertData* GetAssertionReportRaw() => - Underlying.Value!.GetAssertionReportRaw(); + public MaybeBool StartTextInput(WindowHandle window) => T.StartTextInput(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAtomicInt(AtomicInt* a) => Underlying.Value!.GetAtomicInt(a); + public byte StartTextInputRaw(WindowHandle window) => T.StartTextInputRaw(window); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAtomicInt(Ref a) - { - fixed (AtomicInt* __dsl_a = a) - { - return (int)GetAtomicInt(__dsl_a); - } - } + public MaybeBool StartTextInputWithProperties( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.StartTextInputWithProperties(window, props); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetAtomicPointer(void** a) => Underlying.Value!.GetAtomicPointer(a); + public byte StartTextInputWithPropertiesRaw( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => T.StartTextInputWithPropertiesRaw(window, props); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAtomicPointer(Ref2D a) - { - fixed (void** __dsl_a = a) - { - return (void*)GetAtomicPointer(__dsl_a); - } - } + public uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ) => T.StepBackUTF8(start, pstr); [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetAtomicU32(AtomicU32* a) => Underlying.Value!.GetAtomicU32(a); + public uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ) => T.StepBackUTF8(start, pstr); [return: NativeTypeName("Uint32")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetAtomicU32(Ref a) - { - fixed (AtomicU32* __dsl_a = a) - { - return (uint)GetAtomicU32(__dsl_a); - } - } + public uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ) => T.StepUTF8(pstr, pslen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int* GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - int* count - ) => Underlying.Value!.GetAudioDeviceChannelMap(devid, count); + public uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ) => T.StepUTF8(pstr, pslen); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (int*)GetAudioDeviceChannelMap(devid, __dsl_count); - } - } + public MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => + T.StopHapticEffect(haptic, effect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioSpec* spec, - int* sample_frames - ) => Underlying.Value!.GetAudioDeviceFormat(devid, spec, sample_frames); + public byte StopHapticEffectRaw(HapticHandle haptic, int effect) => + T.StopHapticEffectRaw(haptic, effect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref spec, - Ref sample_frames - ) - { - fixed (int* __dsl_sample_frames = sample_frames) - fixed (AudioSpec* __dsl_spec = spec) - { - return (MaybeBool) - (byte)GetAudioDeviceFormat(devid, __dsl_spec, __dsl_sample_frames); - } - } + public MaybeBool StopHapticEffects(HapticHandle haptic) => + T.StopHapticEffects(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - Underlying.Value!.GetAudioDeviceGain(devid); + public byte StopHapticEffectsRaw(HapticHandle haptic) => T.StopHapticEffectsRaw(haptic); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioDeviceName( - [NativeTypeName("SDL_AudioDeviceID")] uint devid - ) => Underlying.Value!.GetAudioDeviceName(devid); + public MaybeBool StopHapticRumble(HapticHandle haptic) => T.StopHapticRumble(haptic); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetAudioDeviceNameRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid - ) => Underlying.Value!.GetAudioDeviceNameRaw(devid); + public byte StopHapticRumbleRaw(HapticHandle haptic) => T.StopHapticRumbleRaw(haptic); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioDriver(int index) => - Underlying.Value!.GetAudioDriver(index); + public MaybeBool StopTextInput(WindowHandle window) => T.StopTextInput(window); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetAudioDriverRaw(int index) => - Underlying.Value!.GetAudioDriverRaw(index); + public byte StopTextInputRaw(WindowHandle window) => T.StopTextInputRaw(window); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioFormatName(AudioFormat format) => - Underlying.Value!.GetAudioFormatName(format); + public MaybeBool StorageReady(StorageHandle storage) => T.StorageReady(storage); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetAudioFormatNameRaw(AudioFormat format) => - Underlying.Value!.GetAudioFormatNameRaw(format); + public byte StorageReadyRaw(StorageHandle storage) => T.StorageReadyRaw(storage); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetAudioPlaybackDevices(int* count) => - Underlying.Value!.GetAudioPlaybackDevices(count); + public int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => T.Strcasecmp(str1, str2); - [return: NativeTypeName("SDL_AudioDeviceID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioPlaybackDevices(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetAudioPlaybackDevices(__dsl_count); - } - } + public int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) => T.Strcasecmp(str1, str2); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetAudioRecordingDevices(int* count) => - Underlying.Value!.GetAudioRecordingDevices(count); + public sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => T.Strcasestr(haystack, needle); - [return: NativeTypeName("SDL_AudioDeviceID *")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioRecordingDevices(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetAudioRecordingDevices(__dsl_count); - } - } + public Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) => T.Strcasestr(haystack, needle); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAudioStreamAvailable(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamAvailable(stream); + public sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c) => + T.Strchr(str, c); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => - Underlying.Value!.GetAudioStreamData(stream, buf, len); + public Ptr Strchr([NativeTypeName("const char *")] Ref str, int c) => + T.Strchr(str, c); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) - { - fixed (void* __dsl_buf = buf) - { - return (int)GetAudioStreamData(stream, __dsl_buf, len); - } - } + public int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => T.Strcmp(str1, str2); - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetAudioStreamDevice(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamDevice(stream); + public int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) => T.Strcmp(str1, str2); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetAudioStreamFormat( - AudioStreamHandle stream, - AudioSpec* src_spec, - AudioSpec* dst_spec - ) => Underlying.Value!.GetAudioStreamFormat(stream, src_spec, dst_spec); + public sbyte* Strdup([NativeTypeName("const char *")] sbyte* str) => T.Strdup(str); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetAudioStreamFormat( - AudioStreamHandle stream, - Ref src_spec, - Ref dst_spec - ) - { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (MaybeBool) - (byte)GetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); - } - } + public Ptr Strdup([NativeTypeName("const char *")] Ref str) => T.Strdup(str); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamFrequencyRatio(stream); + public Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => + T.StringToGuid(pchGUID); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetAudioStreamGain(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamGain(stream); + public Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) => + T.StringToGuid(pchGUID); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => - Underlying.Value!.GetAudioStreamInputChannelMap(stream, count); + public nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strlcat(dst, src, maxlen); + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioStreamInputChannelMap( - AudioStreamHandle stream, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (int*)GetAudioStreamInputChannelMap(stream, __dsl_count); - } - } + public nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strlcat(dst, src, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => - Underlying.Value!.GetAudioStreamOutputChannelMap(stream, count); + public nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strlcpy(dst, src, maxlen); + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (int*)GetAudioStreamOutputChannelMap(stream, __dsl_count); - } - } + public nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strlcpy(dst, src, maxlen); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetAudioStreamProperties(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamProperties(stream); + public nuint Strlen([NativeTypeName("const char *")] sbyte* str) => T.Strlen(str); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetAudioStreamQueued(AudioStreamHandle stream) => - Underlying.Value!.GetAudioStreamQueued(stream); + public nuint Strlen([NativeTypeName("const char *")] Ref str) => T.Strlen(str); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetBasePath() => Underlying.Value!.GetBasePath(); + public sbyte* Strlwr([NativeTypeName("char *")] sbyte* str) => T.Strlwr(str); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetBasePathRaw() => Underlying.Value!.GetBasePathRaw(); + public Ptr Strlwr([NativeTypeName("char *")] Ref str) => T.Strlwr(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => Underlying.Value!.GetBooleanProperty(props, name, default_value); + public int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strncasecmp(str1, str2, maxlen); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool) - (byte)GetBooleanProperty(props, __dsl_name, (byte)default_value); - } - } + public int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strncasecmp(str1, str2, maxlen); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCameraDriver(int index) => - Underlying.Value!.GetCameraDriver(index); + public int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strncmp(str1, str2, maxlen); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetCameraDriverRaw(int index) => - Underlying.Value!.GetCameraDriverRaw(index); + public int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strncmp(str1, str2, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => - Underlying.Value!.GetCameraFormat(camera, spec); + public sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strndup(str, maxlen); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) - { - fixed (CameraSpec* __dsl_spec = spec) - { - return (MaybeBool)(byte)GetCameraFormat(camera, __dsl_spec); - } - } + public Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strndup(str, maxlen); - [return: NativeTypeName("SDL_CameraID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetCameraID(CameraHandle camera) => - Underlying.Value!.GetCameraID(camera); + public nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strnlen(str, maxlen); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => - Underlying.Value!.GetCameraName(instance_id); + public nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strnlen(str, maxlen); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => - Underlying.Value!.GetCameraNameRaw(instance_id); + public sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strnstr(haystack, needle, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetCameraPermissionState(CameraHandle camera) => - Underlying.Value!.GetCameraPermissionState(camera); + public Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Strnstr(haystack, needle, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CameraPosition GetCameraPosition( - [NativeTypeName("SDL_CameraID")] uint instance_id - ) => Underlying.Value!.GetCameraPosition(instance_id); + public sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ) => T.Strpbrk(str, breakset); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetCameraProperties(CameraHandle camera) => - Underlying.Value!.GetCameraProperties(camera); + public Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ) => T.Strpbrk(str, breakset); - [return: NativeTypeName("SDL_CameraID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetCameras(int* count) => Underlying.Value!.GetCameras(count); + public sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c) => + T.Strrchr(str, c); - [return: NativeTypeName("SDL_CameraID *")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCameras(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetCameras(__dsl_count); - } - } + public Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c) => + T.Strrchr(str, c); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CameraSpec** GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - int* count - ) => Underlying.Value!.GetCameraSupportedFormats(devid, count); + public sbyte* Strrev([NativeTypeName("char *")] sbyte* str) => T.Strrev(str); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (CameraSpec**)GetCameraSupportedFormats(devid, __dsl_count); - } - } + public Ptr Strrev([NativeTypeName("char *")] Ref str) => T.Strrev(str); - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetClipboardData( - [NativeTypeName("const char *")] sbyte* mime_type, - [NativeTypeName("size_t *")] nuint* size - ) => Underlying.Value!.GetClipboardData(mime_type, size); + public sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => T.Strstr(haystack, needle); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetClipboardData( - [NativeTypeName("const char *")] Ref mime_type, - [NativeTypeName("size_t *")] Ref size - ) - { - fixed (nuint* __dsl_size = size) - fixed (sbyte* __dsl_mime_type = mime_type) - { - return (void*)GetClipboardData(__dsl_mime_type, __dsl_size); - } - } + public Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) => T.Strstr(haystack, needle); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte** GetClipboardMimeTypes( - [NativeTypeName("size_t *")] nuint* num_mime_types - ) => Underlying.Value!.GetClipboardMimeTypes(num_mime_types); + public double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ) => T.Strtod(str, endp); - [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetClipboardMimeTypes( - [NativeTypeName("size_t *")] Ref num_mime_types - ) - { - fixed (nuint* __dsl_num_mime_types = num_mime_types) - { - return (sbyte**)GetClipboardMimeTypes(__dsl_num_mime_types); - } - } + public double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ) => T.Strtod(str, endp); [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetClipboardText() => Underlying.Value!.GetClipboardText(); + public sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ) => T.StrtokR(s1, s2, saveptr); [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetClipboardTextRaw() => Underlying.Value!.GetClipboardTextRaw(); + public Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ) => T.StrtokR(s1, s2, saveptr); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] byte include_high_density_modes, - DisplayMode* mode - ) => - Underlying.Value!.GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - include_high_density_modes, - mode - ); + public nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => T.Strtol(str, endp, @base); - [return: NativeTypeName("bool")] + [return: NativeTypeName("long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] MaybeBool include_high_density_modes, - Ref mode - ) - { - fixed (DisplayMode* __dsl_mode = mode) - { - return (MaybeBool) - (byte)GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - (byte)include_high_density_modes, - __dsl_mode - ); - } - } + public nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => T.Strtol(str, endp, @base); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] + [return: NativeTypeName("long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetCPUCacheLineSize() => Underlying.Value!.GetCPUCacheLineSize(); + public long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => T.Strtoll(str, endp, @base); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("long long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCurrentAudioDriver() => - Underlying.Value!.GetCurrentAudioDriver(); + public long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => T.Strtoll(str, endp, @base); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [return: NativeTypeName("unsigned long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetCurrentAudioDriverRaw() => - Underlying.Value!.GetCurrentAudioDriverRaw(); + public nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => T.Strtoul(str, endp, @base); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("unsigned long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCurrentCameraDriver() => - Underlying.Value!.GetCurrentCameraDriver(); + public nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => T.Strtoul(str, endp, @base); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [return: NativeTypeName("unsigned long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetCurrentCameraDriverRaw() => - Underlying.Value!.GetCurrentCameraDriverRaw(); + public ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => T.Strtoull(str, endp, @base); - [return: NativeTypeName("const SDL_DisplayMode *")] + [return: NativeTypeName("unsigned long long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr GetCurrentDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetCurrentDisplayMode(displayID); - - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static DisplayMode* GetCurrentDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetCurrentDisplayModeRaw(displayID); + public ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => T.Strtoull(str, endp, @base); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static DisplayOrientation GetCurrentDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetCurrentDisplayOrientation(displayID); + public sbyte* Strupr([NativeTypeName("char *")] sbyte* str) => T.Strupr(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => - Underlying.Value!.GetCurrentRenderOutputSize(renderer, w, h); + public Ptr Strupr([NativeTypeName("char *")] Ref str) => T.Strupr(str); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetCurrentRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h - ) - { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) - { - return (MaybeBool) - (byte)GetCurrentRenderOutputSize(renderer, __dsl_w, __dsl_h); - } - } + public MaybeBool SubmitGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + T.SubmitGPUCommandBuffer(command_buffer); - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetCurrentThreadID() => Underlying.Value!.GetCurrentThreadID(); + public GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ) => T.SubmitGPUCommandBufferAndAcquireFence(command_buffer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => - Underlying.Value!.GetCurrentTime(ticks); + public byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + T.SubmitGPUCommandBufferRaw(command_buffer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) - { - fixed (long* __dsl_ticks = ticks) - { - return (MaybeBool)(byte)GetCurrentTime(__dsl_ticks); - } - } + public byte SurfaceHasAlternateImages(Surface* surface) => + T.SurfaceHasAlternateImages(surface); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetCurrentVideoDriver() => - Underlying.Value!.GetCurrentVideoDriver(); + public MaybeBool SurfaceHasAlternateImages(Ref surface) => + T.SurfaceHasAlternateImages(surface); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetCurrentVideoDriverRaw() => - Underlying.Value!.GetCurrentVideoDriverRaw(); + public byte SurfaceHasColorKey(Surface* surface) => T.SurfaceHasColorKey(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle GetCursor() => Underlying.Value!.GetCursor(); + public MaybeBool SurfaceHasColorKey(Ref surface) => + T.SurfaceHasColorKey(surface); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetDateTimeLocalePreferences( - DateFormat* dateFormat, - TimeFormat* timeFormat - ) => Underlying.Value!.GetDateTimeLocalePreferences(dateFormat, timeFormat); + public byte SurfaceHasRLE(Surface* surface) => T.SurfaceHasRLE(surface); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetDateTimeLocalePreferences( - Ref dateFormat, - Ref timeFormat - ) - { - fixed (TimeFormat* __dsl_timeFormat = timeFormat) - fixed (DateFormat* __dsl_dateFormat = dateFormat) - { - return (MaybeBool) - (byte)GetDateTimeLocalePreferences(__dsl_dateFormat, __dsl_timeFormat); - } - } + public MaybeBool SurfaceHasRLE(Ref surface) => T.SurfaceHasRLE(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetDayOfWeek(int year, int month, int day) => - Underlying.Value!.GetDayOfWeek(year, month, day); + public MaybeBool SyncWindow(WindowHandle window) => T.SyncWindow(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetDayOfYear(int year, int month, int day) => - Underlying.Value!.GetDayOfYear(year, month, day); + public byte SyncWindowRaw(WindowHandle window) => T.SyncWindowRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] + [NativeFunction("SDL3", EntryPoint = "SDL_tan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetDaysInMonth(int year, int month) => - Underlying.Value!.GetDaysInMonth(year, month); + public double Tan(double x) => T.Tan(x); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_tanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertionHandler GetDefaultAssertionHandler() => - Underlying.Value!.GetDefaultAssertionHandler(); + public float Tanf(float x) => T.Tanf(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CursorHandle GetDefaultCursor() => Underlying.Value!.GetDefaultCursor(); + public long TellIO(IOStreamHandle context) => T.TellIO(context); - [return: NativeTypeName("SDL_LogOutputFunction")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static LogOutputFunction GetDefaultLogOutputFunction() => - Underlying.Value!.GetDefaultLogOutputFunction(); + public MaybeBool TextInputActive(WindowHandle window) => T.TextInputActive(window); - [return: NativeTypeName("const SDL_DisplayMode *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetDesktopDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetDesktopDisplayMode(displayID); + public byte TextInputActiveRaw(WindowHandle window) => T.TextInputActiveRaw(window); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [return: NativeTypeName("SDL_Time")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static DisplayMode* GetDesktopDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetDesktopDisplayModeRaw(displayID); + public long TimeFromWindows( + [NativeTypeName("Uint32")] uint dwLowDateTime, + [NativeTypeName("Uint32")] uint dwHighDateTime + ) => T.TimeFromWindows(dwLowDateTime, dwHighDateTime); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => Underlying.Value!.GetDisplayBounds(displayID, rect); + public byte TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + DateTime* dt, + [NativeTypeName("bool")] byte localTime + ) => T.TimeToDateTime(ticks, dt, localTime); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)GetDisplayBounds(displayID, __dsl_rect); - } - } + public MaybeBool TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + Ref dt, + [NativeTypeName("bool")] MaybeBool localTime + ) => T.TimeToDateTime(ticks, dt, localTime); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetDisplayContentScale( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetDisplayContentScale(displayID); + public void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] uint* dwLowDateTime, + [NativeTypeName("Uint32 *")] uint* dwHighDateTime + ) => T.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => - Underlying.Value!.GetDisplayForPoint(point); + public void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] Ref dwLowDateTime, + [NativeTypeName("Uint32 *")] Ref dwHighDateTime + ) => T.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); - [return: NativeTypeName("SDL_DisplayID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [NativeFunction("SDL3", EntryPoint = "SDL_tolower")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayForPoint( - [NativeTypeName("const SDL_Point *")] Ref point - ) - { - fixed (Point* __dsl_point = point) - { - return (uint)GetDisplayForPoint(__dsl_point); - } - } + public int Tolower(int x) => T.Tolower(x); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_toupper")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => - Underlying.Value!.GetDisplayForRect(rect); + public int Toupper(int x) => T.Toupper(x); - [return: NativeTypeName("SDL_DisplayID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_trunc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) - { - fixed (Rect* __dsl_rect = rect) - { - return (uint)GetDisplayForRect(__dsl_rect); - } - } + public double Trunc(double x) => T.Trunc(x); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_truncf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayForWindow(WindowHandle window) => - Underlying.Value!.GetDisplayForWindow(window); + public float Truncf(float x) => T.Truncf(x); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => - Underlying.Value!.GetDisplayName(displayID); + public MaybeBool TryLockMutex(MutexHandle mutex) => T.TryLockMutex(mutex); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => - Underlying.Value!.GetDisplayNameRaw(displayID); + public byte TryLockMutexRaw(MutexHandle mutex) => T.TryLockMutexRaw(mutex); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => - Underlying.Value!.GetDisplayProperties(displayID); + public MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => + T.TryLockRWLockForReading(rwlock); - [return: NativeTypeName("SDL_DisplayID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetDisplays(int* count) => Underlying.Value!.GetDisplays(count); + public byte TryLockRWLockForReadingRaw(RWLockHandle rwlock) => + T.TryLockRWLockForReadingRaw(rwlock); - [return: NativeTypeName("SDL_DisplayID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetDisplays(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetDisplays(__dsl_count); - } - } + public MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => + T.TryLockRWLockForWriting(rwlock); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => Underlying.Value!.GetDisplayUsableBounds(displayID, rect); + public byte TryLockRWLockForWritingRaw(RWLockHandle rwlock) => + T.TryLockRWLockForWritingRaw(rwlock); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)GetDisplayUsableBounds(displayID, __dsl_rect); - } - } + public byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + T.TryLockSpinlock(@lock); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetError() => Underlying.Value!.GetError(); + public MaybeBool TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => + T.TryLockSpinlock(@lock); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetErrorRaw() => Underlying.Value!.GetErrorRaw(); + public MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => T.TryWaitSemaphore(sem); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, - void** userdata - ) => Underlying.Value!.GetEventFilter(filter, userdata); + public byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => T.TryWaitSemaphoreRaw(sem); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ) => T.UCS4ToUTF8(codepoint, dst); + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] Ref filter, - Ref2D userdata - ) - { - fixed (void** __dsl_userdata = userdata) - fixed (EventFilter* __dsl_filter = filter) - { - return (MaybeBool)(byte)GetEventFilter(__dsl_filter, __dsl_userdata); - } - } + public Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ) => T.UCS4ToUTF8(codepoint, dst); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float default_value - ) => Underlying.Value!.GetFloatProperty(props, name, default_value); + public sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => T.Uitoa(value, str, radix); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float default_value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (float)GetFloatProperty(props, __dsl_name, default_value); - } - } + public Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => T.Uitoa(value, str, radix); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static DisplayMode** GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int* count - ) => Underlying.Value!.GetFullscreenDisplayModes(displayID, count); + public sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => T.Ulltoa(value, str, radix); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (DisplayMode**)GetFullscreenDisplayModes(displayID, __dsl_count); - } - } + public Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ) => T.Ulltoa(value, str, radix); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadAppleSFSymbolsNameForAxis( - GamepadHandle gamepad, - GamepadAxis axis - ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); + public sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => T.Ultoa(value, str, radix); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( - GamepadHandle gamepad, - GamepadAxis axis - ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); + public Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => T.Ultoa(value, str, radix); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadAppleSFSymbolsNameForButton( - GamepadHandle gamepad, - GamepadButton button - ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); + public void UnbindAudioStream(AudioStreamHandle stream) => T.UnbindAudioStream(stream); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( - GamepadHandle gamepad, - GamepadButton button - ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); + public void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams) => + T.UnbindAudioStreams(streams, num_streams); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => - Underlying.Value!.GetGamepadAxis(gamepad, axis); + public void UnbindAudioStreams(Ref streams, int num_streams) => + T.UnbindAudioStreams(streams, num_streams); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnloadObject")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadAxis GetGamepadAxisFromString( - [NativeTypeName("const char *")] sbyte* str - ) => Underlying.Value!.GetGamepadAxisFromString(str); + public void UnloadObject(SharedObjectHandle handle) => T.UnloadObject(handle); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadAxis GetGamepadAxisFromString( - [NativeTypeName("const char *")] Ref str - ) - { - fixed (sbyte* __dsl_str = str) - { - return (GamepadAxis)GetGamepadAxisFromString(__dsl_str); - } - } + public MaybeBool UnlockAudioStream(AudioStreamHandle stream) => + T.UnlockAudioStream(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => - Underlying.Value!.GetGamepadBindings(gamepad, count); + public byte UnlockAudioStreamRaw(AudioStreamHandle stream) => + T.UnlockAudioStreamRaw(stream); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetGamepadBindings( - GamepadHandle gamepad, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (GamepadBinding**)GetGamepadBindings(gamepad, __dsl_count); - } - } + public void UnlockJoysticks() => T.UnlockJoysticks(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetGamepadButton( - GamepadHandle gamepad, - GamepadButton button - ) => Underlying.Value!.GetGamepadButton(gamepad, button); + public void UnlockMutex(MutexHandle mutex) => T.UnlockMutex(mutex); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] sbyte* str - ) => Underlying.Value!.GetGamepadButtonFromString(str); + public void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + T.UnlockProperties(props); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockRWLock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] Ref str - ) - { - fixed (sbyte* __dsl_str = str) - { - return (GamepadButton)GetGamepadButtonFromString(__dsl_str); - } - } + public void UnlockRWLock(RWLockHandle rwlock) => T.UnlockRWLock(rwlock); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadButtonLabel GetGamepadButtonLabel( - GamepadHandle gamepad, - GamepadButton button - ) => Underlying.Value!.GetGamepadButtonLabel(gamepad, button); + public void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + T.UnlockSpinlock(@lock); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadButtonLabel GetGamepadButtonLabelForType( - GamepadType type, - GamepadButton button - ) => Underlying.Value!.GetGamepadButtonLabelForType(type, button); + public void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => + T.UnlockSpinlock(@lock); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => - Underlying.Value!.GetGamepadButtonRaw(gamepad, button); + public void UnlockSurface(Surface* surface) => T.UnlockSurface(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadConnectionState(gamepad); + public void UnlockSurface(Ref surface) => T.UnlockSurface(surface); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadFirmwareVersion(gamepad); + public void UnlockTexture(Texture* texture) => T.UnlockTexture(texture); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadHandle GetGamepadFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadFromID(instance_id); + public void UnlockTexture(Ref texture) => T.UnlockTexture(texture); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnmapGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadHandle GetGamepadFromPlayerIndex(int player_index) => - Underlying.Value!.GetGamepadFromPlayerIndex(player_index); + public void UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => T.UnmapGPUTransferBuffer(device, transfer_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid GetGamepadGuidForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadGuidForID(instance_id); + public int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + T.UnsetenvUnsafe(name); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetGamepadID(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadID(gamepad); + public int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name) => + T.UnsetenvUnsafe(name); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadJoystick(gamepad); + public byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => T.UnsetEnvironmentVariable(env, name); - [return: NativeTypeName("char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadMapping(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadMapping(gamepad); + public MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) => T.UnsetEnvironmentVariable(env, name); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadMappingForGuid(Guid guid) => - Underlying.Value!.GetGamepadMappingForGuid(guid); + public void UpdateGamepads() => T.UpdateGamepads(); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadMappingForGuidRaw(Guid guid) => - Underlying.Value!.GetGamepadMappingForGuidRaw(guid); + public byte UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data + ) => T.UpdateHapticEffect(haptic, effect, data); - [return: NativeTypeName("char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadMappingForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadMappingForID(instance_id); + public MaybeBool UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] Ref data + ) => T.UpdateHapticEffect(haptic, effect, data); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadMappingForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadMappingForIDRaw(instance_id); + public void UpdateJoysticks() => T.UpdateJoysticks(); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadMappingRaw(gamepad); + public byte UpdateNVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* UVplane, + int UVpitch + ) => T.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte** GetGamepadMappings(int* count) => - Underlying.Value!.GetGamepadMappings(count); + public MaybeBool UpdateNVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref UVplane, + int UVpitch + ) => T.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateSensors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetGamepadMappings(Ref count) - { - fixed (int* __dsl_count = count) - { - return (sbyte**)GetGamepadMappings(__dsl_count); - } - } + public void UpdateSensors() => T.UpdateSensors(); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadName(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadName(gamepad); + public byte UpdateTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const void *")] void* pixels, + int pitch + ) => T.UpdateTexture(texture, rect, pixels, pitch); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadNameForID(instance_id); + public MaybeBool UpdateTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const void *")] Ref pixels, + int pitch + ) => T.UpdateTexture(texture, rect, pixels, pitch); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadNameForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadNameForIDRaw(instance_id); + public MaybeBool UpdateWindowSurface(WindowHandle window) => + T.UpdateWindowSurface(window); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadNameRaw(gamepad); + public byte UpdateWindowSurfaceRaw(WindowHandle window) => T.UpdateWindowSurfaceRaw(window); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadPath(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadPath(gamepad); + public byte UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int numrects + ) => T.UpdateWindowSurfaceRects(window, rects, numrects); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadPathForID(instance_id); + public MaybeBool UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rects, + int numrects + ) => T.UpdateWindowSurfaceRects(window, rects, numrects); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadPathForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadPathForIDRaw(instance_id); + public byte UpdateYUVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] byte* Vplane, + int Vpitch + ) => T.UpdateYUVTexture(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadPathRaw(gamepad); + public MaybeBool UpdateYUVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] Ref Vplane, + int Vpitch + ) => T.UpdateYUVTexture(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetGamepadPlayerIndex(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadPlayerIndex(gamepad); + public void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => T.UploadToGPUBuffer(copy_pass, source, destination, cycle); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetGamepadPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadPlayerIndexForID(instance_id); + public void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) => T.UploadToGPUBuffer(copy_pass, source, destination, cycle); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => - Underlying.Value!.GetGamepadPowerInfo(gamepad, percent); + public void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => T.UploadToGPUTexture(copy_pass, source, destination, cycle); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) - { - fixed (int* __dsl_percent = percent) - { - return (PowerState)GetGamepadPowerInfo(gamepad, __dsl_percent); - } - } + public void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) => T.UploadToGPUTexture(copy_pass, source, destination, cycle); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadProduct(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadProduct(gamepad); + public nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => T.Utf8Strlcpy(dst, src, dst_bytes); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadProductForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadProductForID(instance_id); + public nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => T.Utf8Strlcpy(dst, src, dst_bytes); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadProductVersion(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadProductVersion(gamepad); + public nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str) => T.Utf8Strlen(str); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadProductVersionForID(instance_id); + public nuint Utf8Strlen([NativeTypeName("const char *")] Ref str) => + T.Utf8Strlen(str); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetGamepadProperties(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadProperties(gamepad); + public nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ) => T.Utf8Strnlen(str, bytes); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetGamepads(int* count) => Underlying.Value!.GetGamepads(count); + public nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ) => T.Utf8Strnlen(str, bytes); - [return: NativeTypeName("SDL_JoystickID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepads(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetGamepads(__dsl_count); - } - } + public int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.Vasprintf(strp, fmt, ap); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - float* data, - int num_values - ) => Underlying.Value!.GetGamepadSensorData(gamepad, type, data, num_values); + public int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.Vasprintf(strp, fmt, ap); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - Ref data, - int num_values - ) - { - fixed (float* __dsl_data = data) - { - return (MaybeBool) - (byte)GetGamepadSensorData(gamepad, type, __dsl_data, num_values); - } - } + public int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.Vsnprintf(text, maxlen, fmt, ap); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => - Underlying.Value!.GetGamepadSensorDataRate(gamepad, type); + public int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.Vsnprintf(text, maxlen, fmt, ap); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadSerial(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadSerial(gamepad); + public int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.Vsscanf(text, fmt, ap); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadSerialRaw(gamepad); + public int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.Vsscanf(text, fmt, ap); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetGamepadSteamHandle(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadSteamHandle(gamepad); + public int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => T.Vswprintf(text, maxlen, fmt, ap); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadStringForAxis(GamepadAxis axis) => - Underlying.Value!.GetGamepadStringForAxis(axis); + public int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => T.Vswprintf(text, maxlen, fmt, ap); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => - Underlying.Value!.GetGamepadStringForAxisRaw(axis); + public byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ) => T.VulkanCreateSurface(window, instance, allocator, surface); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadStringForButton(GamepadButton button) => - Underlying.Value!.GetGamepadStringForButton(button); + public MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ) => T.VulkanCreateSurface(window, instance, allocator, surface); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => - Underlying.Value!.GetGamepadStringForButtonRaw(button); + public void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ) => T.VulkanDestroySurface(instance, surface, allocator); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetGamepadStringForType(GamepadType type) => - Underlying.Value!.GetGamepadStringForType(type); + public void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ) => T.VulkanDestroySurface(instance, surface, allocator); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [return: NativeTypeName("const char *const *")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetGamepadStringForTypeRaw(GamepadType type) => - Underlying.Value!.GetGamepadStringForTypeRaw(type); + public sbyte** VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] uint* count) => + T.VulkanGetInstanceExtensions(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [return: NativeTypeName("const char *const *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - bool* down, - float* x, - float* y, - float* pressure - ) => - Underlying.Value!.GetGamepadTouchpadFinger( - gamepad, - touchpad, - finger, - down, - x, - y, - pressure - ); + public Ptr2D VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] Ref count + ) => T.VulkanGetInstanceExtensions(count); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - Ref down, - Ref x, - Ref y, - Ref pressure - ) - { - fixed (float* __dsl_pressure = pressure) - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) - fixed (bool* __dsl_down = down) - { - return (MaybeBool) - (byte)GetGamepadTouchpadFinger( - gamepad, - touchpad, - finger, - __dsl_down, - __dsl_x, - __dsl_y, - __dsl_pressure - ); - } - } + public byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => T.VulkanGetPresentationSupport(instance, physicalDevice, queueFamilyIndex); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadType GetGamepadType(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadType(gamepad); + public MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => T.VulkanGetPresentationSupport(instance, physicalDevice, queueFamilyIndex); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadType GetGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadTypeForID(instance_id); + public FunctionPointer VulkanGetVkGetInstanceProcAddr() => + T.VulkanGetVkGetInstanceProcAddr(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadType GetGamepadTypeFromString( - [NativeTypeName("const char *")] sbyte* str - ) => Underlying.Value!.GetGamepadTypeFromString(str); + public byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + T.VulkanLoadLibrary(path); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static GamepadType GetGamepadTypeFromString( - [NativeTypeName("const char *")] Ref str - ) - { - fixed (sbyte* __dsl_str = str) - { - return (GamepadType)GetGamepadTypeFromString(__dsl_str); - } - } - - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadVendor(GamepadHandle gamepad) => - Underlying.Value!.GetGamepadVendor(gamepad); + public MaybeBool VulkanLoadLibrary( + [NativeTypeName("const char *")] Ref path + ) => T.VulkanLoadLibrary(path); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_UnloadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetGamepadVendorForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetGamepadVendorForID(instance_id); + public void VulkanUnloadLibrary() => T.VulkanUnloadLibrary(); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetGlobalMouseState(float* x, float* y) => - Underlying.Value!.GetGlobalMouseState(x, y); + public void WaitCondition(ConditionHandle cond, MutexHandle mutex) => + T.WaitCondition(cond, mutex); - [return: NativeTypeName("SDL_MouseButtonFlags")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetGlobalMouseState(Ref x, Ref y) - { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) - { - return (uint)GetGlobalMouseState(__dsl_x, __dsl_y); - } - } + public MaybeBool WaitConditionTimeout( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ) => T.WaitConditionTimeout(cond, mutex, timeoutMS); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetGlobalProperties() => Underlying.Value!.GetGlobalProperties(); + public byte WaitConditionTimeoutRaw( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ) => T.WaitConditionTimeoutRaw(cond, mutex, timeoutMS); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetGrabbedWindow() => Underlying.Value!.GetGrabbedWindow(); + public byte WaitEvent(Event* @event) => T.WaitEvent(@event); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => - Underlying.Value!.GetHapticEffectStatus(haptic, effect); + public MaybeBool WaitEvent(Ref @event) => T.WaitEvent(@event); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => - Underlying.Value!.GetHapticEffectStatusRaw(haptic, effect); + public byte WaitEventTimeout(Event* @event, [NativeTypeName("Sint32")] int timeoutMS) => + T.WaitEventTimeout(@event, timeoutMS); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetHapticFeatures(HapticHandle haptic) => - Underlying.Value!.GetHapticFeatures(haptic); + public MaybeBool WaitEventTimeout( + Ref @event, + [NativeTypeName("Sint32")] int timeoutMS + ) => T.WaitEventTimeout(@event, timeoutMS); - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HapticHandle GetHapticFromID( - [NativeTypeName("SDL_HapticID")] uint instance_id - ) => Underlying.Value!.GetHapticFromID(instance_id); + public byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ) => T.WaitForGPUFences(device, wait_all, fences, num_fences); - [return: NativeTypeName("SDL_HapticID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetHapticID(HapticHandle haptic) => - Underlying.Value!.GetHapticID(haptic); + public MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ) => T.WaitForGPUFences(device, wait_all, fences, num_fences); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetHapticName(HapticHandle haptic) => - Underlying.Value!.GetHapticName(haptic); + public MaybeBool WaitForGPUIdle(GPUDeviceHandle device) => T.WaitForGPUIdle(device); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetHapticNameForID( - [NativeTypeName("SDL_HapticID")] uint instance_id - ) => Underlying.Value!.GetHapticNameForID(instance_id); + public byte WaitForGPUIdleRaw(GPUDeviceHandle device) => T.WaitForGPUIdleRaw(device); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetHapticNameForIDRaw( - [NativeTypeName("SDL_HapticID")] uint instance_id - ) => Underlying.Value!.GetHapticNameForIDRaw(instance_id); + public byte WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ) => T.WaitProcess(process, block, exitcode); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetHapticNameRaw(HapticHandle haptic) => - Underlying.Value!.GetHapticNameRaw(haptic); + public MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ) => T.WaitProcess(process, block, exitcode); - [return: NativeTypeName("SDL_HapticID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetHaptics(int* count) => Underlying.Value!.GetHaptics(count); + public void WaitSemaphore(SemaphoreHandle sem) => T.WaitSemaphore(sem); - [return: NativeTypeName("SDL_HapticID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetHaptics(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetHaptics(__dsl_count); - } - } + public MaybeBool WaitSemaphoreTimeout( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ) => T.WaitSemaphoreTimeout(sem, timeoutMS); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => - Underlying.Value!.GetHint(name); + public byte WaitSemaphoreTimeoutRaw( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ) => T.WaitSemaphoreTimeoutRaw(sem, timeoutMS); + + [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public void WaitThread(ThreadHandle thread, int* status) => T.WaitThread(thread, status); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetHint([NativeTypeName("const char *")] Ref name) - { - fixed (sbyte* __dsl_name = name) - { - return (sbyte*)GetHint(__dsl_name); - } - } + public void WaitThread(ThreadHandle thread, Ref status) => + T.WaitThread(thread, status); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetHintBoolean( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => Underlying.Value!.GetHintBoolean(name, default_value); + public MaybeBool WarpMouseGlobal(float x, float y) => T.WarpMouseGlobal(x, y); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetHintBoolean( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)GetHintBoolean(__dsl_name, (byte)default_value); - } - } + public byte WarpMouseGlobalRaw(float x, float y) => T.WarpMouseGlobalRaw(x, y); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseInWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetIOProperties(IOStreamHandle context) => - Underlying.Value!.GetIOProperties(context); + public void WarpMouseInWindow(WindowHandle window, float x, float y) => + T.WarpMouseInWindow(window, x, y); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] + [return: NativeTypeName("SDL_InitFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long GetIOSize(IOStreamHandle context) => - Underlying.Value!.GetIOSize(context); + public uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => T.WasInit(flags); - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStatus GetIOStatus(IOStreamHandle context) => - Underlying.Value!.GetIOStatus(context); + public int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => T.Wcscasecmp(str1, str2); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static short GetJoystickAxis(JoystickHandle joystick, int axis) => - Underlying.Value!.GetJoystickAxis(joystick, axis); + public int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) => T.Wcscasecmp(str1, str2); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] short* state - ) => Underlying.Value!.GetJoystickAxisInitialState(joystick, axis, state); + public int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => T.Wcscmp(str1, str2); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] Ref state - ) - { - fixed (short* __dsl_state = state) - { - return (MaybeBool) - (byte)GetJoystickAxisInitialState(joystick, axis, __dsl_state); - } - } + public int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) => T.Wcscmp(str1, str2); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => - Underlying.Value!.GetJoystickBall(joystick, ball, dx, dy); + public uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr) => T.Wcsdup(wstr); - [return: NativeTypeName("bool")] + [return: NativeTypeName("wchar_t *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetJoystickBall( - JoystickHandle joystick, - int ball, - Ref dx, - Ref dy - ) - { - fixed (int* __dsl_dy = dy) - fixed (int* __dsl_dx = dx) - { - return (MaybeBool)(byte)GetJoystickBall(joystick, ball, __dsl_dx, __dsl_dy); - } - } + public Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr) => + T.Wcsdup(wstr); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => - Underlying.Value!.GetJoystickButton(joystick, button); + public nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcslcat(dst, src, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => - Underlying.Value!.GetJoystickButtonRaw(joystick, button); + public nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcslcat(dst, src, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => - Underlying.Value!.GetJoystickConnectionState(joystick); + public nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcslcpy(dst, src, maxlen); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => - Underlying.Value!.GetJoystickFirmwareVersion(joystick); + public nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcslcpy(dst, src, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickHandle GetJoystickFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickFromID(instance_id); + public nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr) => T.Wcslen(wstr); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickHandle GetJoystickFromPlayerIndex(int player_index) => - Underlying.Value!.GetJoystickFromPlayerIndex(player_index); + public nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr) => T.Wcslen(wstr); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid GetJoystickGuid(JoystickHandle joystick) => - Underlying.Value!.GetJoystickGuid(joystick); + public int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsncasecmp(str1, str2, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid GetJoystickGuidForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickGuidForID(instance_id); + public int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsncasecmp(str1, str2, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] ushort* vendor, - [NativeTypeName("Uint16 *")] ushort* product, - [NativeTypeName("Uint16 *")] ushort* version, - [NativeTypeName("Uint16 *")] ushort* crc16 - ) => Underlying.Value!.GetJoystickGuidInfo(guid, vendor, product, version, crc16); + public int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsncmp(str1, str2, maxlen); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] Ref vendor, - [NativeTypeName("Uint16 *")] Ref product, - [NativeTypeName("Uint16 *")] Ref version, - [NativeTypeName("Uint16 *")] Ref crc16 - ) - { - fixed (ushort* __dsl_crc16 = crc16) - fixed (ushort* __dsl_version = version) - fixed (ushort* __dsl_product = product) - fixed (ushort* __dsl_vendor = vendor) - { - GetJoystickGuidInfo(guid, __dsl_vendor, __dsl_product, __dsl_version, __dsl_crc16); - } - } + public int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsncmp(str1, str2, maxlen); - [return: NativeTypeName("Uint8")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetJoystickHat(JoystickHandle joystick, int hat) => - Underlying.Value!.GetJoystickHat(joystick, hat); + public nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsnlen(wstr, maxlen); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetJoystickID(JoystickHandle joystick) => - Underlying.Value!.GetJoystickID(joystick); + public nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsnlen(wstr, maxlen); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoystickName(JoystickHandle joystick) => - Underlying.Value!.GetJoystickName(joystick); + public uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsnstr(haystack, needle, maxlen); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("wchar_t *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoystickNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickNameForID(instance_id); + public Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) => T.Wcsnstr(haystack, needle, maxlen); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetJoystickNameForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickNameForIDRaw(instance_id); + public uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ) => T.Wcsstr(haystack, needle); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetJoystickNameRaw(JoystickHandle joystick) => - Underlying.Value!.GetJoystickNameRaw(joystick); + public Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ) => T.Wcsstr(haystack, needle); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoystickPath(JoystickHandle joystick) => - Underlying.Value!.GetJoystickPath(joystick); + public nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ) => T.Wcstol(str, endp, @base); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoystickPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickPathForID(instance_id); + public nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ) => T.Wcstol(str, endp, @base); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetJoystickPathForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickPathForIDRaw(instance_id); + public MaybeBool WindowHasSurface(WindowHandle window) => T.WindowHasSurface(window); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetJoystickPathRaw(JoystickHandle joystick) => - Underlying.Value!.GetJoystickPathRaw(joystick); + public byte WindowHasSurfaceRaw(WindowHandle window) => T.WindowHasSurfaceRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetJoystickPlayerIndex(JoystickHandle joystick) => - Underlying.Value!.GetJoystickPlayerIndex(joystick); + public MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => T.WindowSupportsGPUPresentMode(device, window, present_mode); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetJoystickPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickPlayerIndexForID(instance_id); + public byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => T.WindowSupportsGPUPresentModeRaw(device, window, present_mode); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => - Underlying.Value!.GetJoystickPowerInfo(joystick, percent); + public MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => T.WindowSupportsGPUSwapchainComposition(device, window, swapchain_composition); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) - { - fixed (int* __dsl_percent = percent) - { - return (PowerState)GetJoystickPowerInfo(joystick, __dsl_percent); - } - } + public byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => T.WindowSupportsGPUSwapchainCompositionRaw(device, window, swapchain_composition); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickProduct(JoystickHandle joystick) => - Underlying.Value!.GetJoystickProduct(joystick); + public nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] void* ptr, + [NativeTypeName("size_t")] nuint size + ) => T.WriteIO(context, ptr, size); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickProductForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickProductForID(instance_id); + public nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] Ref ptr, + [NativeTypeName("size_t")] nuint size + ) => T.WriteIO(context, ptr, size); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickProductVersion(JoystickHandle joystick) => - Underlying.Value!.GetJoystickProductVersion(joystick); + public MaybeBool WriteS16BE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => T.WriteS16BE(dst, value); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickProductVersionForID(instance_id); + public byte WriteS16BERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => + T.WriteS16BERaw(dst, value); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetJoystickProperties(JoystickHandle joystick) => - Underlying.Value!.GetJoystickProperties(joystick); + public MaybeBool WriteS16LE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => T.WriteS16LE(dst, value); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetJoysticks(int* count) => Underlying.Value!.GetJoysticks(count); + public byte WriteS16LERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => + T.WriteS16LERaw(dst, value); - [return: NativeTypeName("SDL_JoystickID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoysticks(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetJoysticks(__dsl_count); - } - } + public MaybeBool WriteS32BE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => T.WriteS32BE(dst, value); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetJoystickSerial(JoystickHandle joystick) => - Underlying.Value!.GetJoystickSerial(joystick); + public byte WriteS32BERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => + T.WriteS32BERaw(dst, value); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => - Underlying.Value!.GetJoystickSerialRaw(joystick); + public MaybeBool WriteS32LE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => T.WriteS32LE(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickType GetJoystickType(JoystickHandle joystick) => - Underlying.Value!.GetJoystickType(joystick); + public byte WriteS32LERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => + T.WriteS32LERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickType GetJoystickTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickTypeForID(instance_id); + public MaybeBool WriteS64BE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => T.WriteS64BE(dst, value); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickVendor(JoystickHandle joystick) => - Underlying.Value!.GetJoystickVendor(joystick); + public byte WriteS64BERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => + T.WriteS64BERaw(dst, value); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetJoystickVendorForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetJoystickVendorForID(instance_id); + public MaybeBool WriteS64LE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => T.WriteS64LE(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetKeyboardFocus() => Underlying.Value!.GetKeyboardFocus(); + public byte WriteS64LERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => + T.WriteS64LERaw(dst, value); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetKeyboardNameForID( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => Underlying.Value!.GetKeyboardNameForID(instance_id); + public MaybeBool WriteS8(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => + T.WriteS8(dst, value); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetKeyboardNameForIDRaw( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => Underlying.Value!.GetKeyboardNameForIDRaw(instance_id); + public byte WriteS8Raw(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => + T.WriteS8Raw(dst, value); - [return: NativeTypeName("SDL_KeyboardID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetKeyboards(int* count) => Underlying.Value!.GetKeyboards(count); + public byte WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const void *")] void* source, + [NativeTypeName("Uint64")] ulong length + ) => T.WriteStorageFile(storage, path, source, length); - [return: NativeTypeName("SDL_KeyboardID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetKeyboards(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetKeyboards(__dsl_count); - } - } + public MaybeBool WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const void *")] Ref source, + [NativeTypeName("Uint64")] ulong length + ) => T.WriteStorageFile(storage, path, source, length); - [return: NativeTypeName("const bool *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static bool* GetKeyboardState(int* numkeys) => - Underlying.Value!.GetKeyboardState(numkeys); + public byte WriteSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.WriteSurfacePixel(surface, x, y, r, g, b, a); - [return: NativeTypeName("const bool *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetKeyboardState(Ref numkeys) - { - fixed (int* __dsl_numkeys = numkeys) - { - return (bool*)GetKeyboardState(__dsl_numkeys); - } - } + public MaybeBool WriteSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => T.WriteSurfacePixel(surface, x, y, r, g, b, a); - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => - Underlying.Value!.GetKeyFromName(name); + public byte WriteSurfacePixelFloat( + Surface* surface, + int x, + int y, + float r, + float g, + float b, + float a + ) => T.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); - [return: NativeTypeName("SDL_Keycode")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetKeyFromName([NativeTypeName("const char *")] Ref name) - { - fixed (sbyte* __dsl_name = name) - { - return (uint)GetKeyFromName(__dsl_name); - } - } + public MaybeBool WriteSurfacePixelFloat( + Ref surface, + int x, + int y, + float r, + float g, + float b, + float a + ) => T.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] byte key_event - ) => Underlying.Value!.GetKeyFromScancode(scancode, modstate, key_event); + public MaybeBool WriteU16BE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => T.WriteU16BE(dst, value); - [return: NativeTypeName("SDL_Keycode")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] MaybeBool key_event - ) => Underlying.Value!.GetKeyFromScancode(scancode, modstate, key_event); + public byte WriteU16BERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => + T.WriteU16BERaw(dst, value); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => - Underlying.Value!.GetKeyName(key); + public MaybeBool WriteU16LE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => T.WriteU16LE(dst, value); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => - Underlying.Value!.GetKeyNameRaw(key); + public byte WriteU16LERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => + T.WriteU16LERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, - void** userdata - ) => Underlying.Value!.GetLogOutputFunction(callback, userdata); + public MaybeBool WriteU32BE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => T.WriteU32BE(dst, value); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, - Ref2D userdata - ) - { - fixed (void** __dsl_userdata = userdata) - fixed (LogOutputFunction* __dsl_callback = callback) - { - GetLogOutputFunction(__dsl_callback, __dsl_userdata); - } - } + public byte WriteU32BERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => + T.WriteU32BERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static LogPriority GetLogPriority(int category) => - Underlying.Value!.GetLogPriority(category); + public MaybeBool WriteU32LE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => T.WriteU32LE(dst, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetMasksForPixelFormat( - PixelFormat format, - int* bpp, - [NativeTypeName("Uint32 *")] uint* Rmask, - [NativeTypeName("Uint32 *")] uint* Gmask, - [NativeTypeName("Uint32 *")] uint* Bmask, - [NativeTypeName("Uint32 *")] uint* Amask - ) => Underlying.Value!.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); + public byte WriteU32LERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => + T.WriteU32LERaw(dst, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetMasksForPixelFormat( - PixelFormat format, - Ref bpp, - [NativeTypeName("Uint32 *")] Ref Rmask, - [NativeTypeName("Uint32 *")] Ref Gmask, - [NativeTypeName("Uint32 *")] Ref Bmask, - [NativeTypeName("Uint32 *")] Ref Amask - ) - { - fixed (uint* __dsl_Amask = Amask) - fixed (uint* __dsl_Bmask = Bmask) - fixed (uint* __dsl_Gmask = Gmask) - fixed (uint* __dsl_Rmask = Rmask) - fixed (int* __dsl_bpp = bpp) - { - return (MaybeBool) - (byte)GetMasksForPixelFormat( - format, - __dsl_bpp, - __dsl_Rmask, - __dsl_Gmask, - __dsl_Bmask, - __dsl_Amask - ); - } - } + public MaybeBool WriteU64BE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => T.WriteU64BE(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetMaxHapticEffects(HapticHandle haptic) => - Underlying.Value!.GetMaxHapticEffects(haptic); + public byte WriteU64BERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => + T.WriteU64BERaw(dst, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetMaxHapticEffectsPlaying(HapticHandle haptic) => - Underlying.Value!.GetMaxHapticEffectsPlaying(haptic); + public MaybeBool WriteU64LE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => T.WriteU64LE(dst, value); - [return: NativeTypeName("SDL_MouseID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetMice(int* count) => Underlying.Value!.GetMice(count); + public byte WriteU64LERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => + T.WriteU64LERaw(dst, value); - [return: NativeTypeName("SDL_MouseID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetMice(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetMice(__dsl_count); - } - } + public MaybeBool WriteU8(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => + T.WriteU8(dst, value); - [return: NativeTypeName("SDL_Keymod")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ushort GetModState() => Underlying.Value!.GetModState(); + public byte WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => + T.WriteU8Raw(dst, value); + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] + public partial class ThisThread + { + [NativeFunction("SDL3", EntryPoint = "SDL_abs")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetMouseFocus() => Underlying.Value!.GetMouseFocus(); + public static int Abs(int x) => Underlying.Value!.Abs(x); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_acos")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetMouseNameForID( - [NativeTypeName("SDL_MouseID")] uint instance_id - ) => Underlying.Value!.GetMouseNameForID(instance_id); + public static double Acos(double x) => Underlying.Value!.Acos(x); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_acosf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetMouseNameForIDRaw( - [NativeTypeName("SDL_MouseID")] uint instance_id - ) => Underlying.Value!.GetMouseNameForIDRaw(instance_id); + public static float Acosf(float x) => Underlying.Value!.Acosf(x); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetMouseState(float* x, float* y) => - Underlying.Value!.GetMouseState(x, y); - - [return: NativeTypeName("SDL_MouseButtonFlags")] + public static Surface* AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] ulong* timestampNS + ) => Underlying.Value!.AcquireCameraFrame(camera, timestampNS); + [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetMouseState(Ref x, Ref y) + public static Ptr AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] Ref timestampNS + ) { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) + fixed (ulong* __dsl_timestampNS = timestampNS) { - return (uint)GetMouseState(__dsl_x, __dsl_y); + return (Surface*)AcquireCameraFrame(camera, __dsl_timestampNS); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static DisplayOrientation GetNaturalDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => Underlying.Value!.GetNaturalDisplayOrientation(displayID); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumAudioDrivers() => Underlying.Value!.GetNumAudioDrivers(); + public static GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device) => + Underlying.Value!.AcquireGPUCommandBuffer(device); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long default_value - ) => Underlying.Value!.GetNumberProperty(props, name, default_value); + public static byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ) => + Underlying.Value!.AcquireGPUSwapchainTexture( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); - [return: NativeTypeName("Sint64")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long default_value + public static MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height ) { - fixed (sbyte* __dsl_name = name) + fixed (uint* __dsl_swapchain_texture_height = swapchain_texture_height) + fixed (uint* __dsl_swapchain_texture_width = swapchain_texture_width) + fixed (GPUTextureHandle* __dsl_swapchain_texture = swapchain_texture) { - return (long)GetNumberProperty(props, __dsl_name, default_value); + return (MaybeBool) + (byte)AcquireGPUSwapchainTexture( + command_buffer, + window, + __dsl_swapchain_texture, + __dsl_swapchain_texture_width, + __dsl_swapchain_texture_height + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static int GetNumCameraDrivers() => Underlying.Value!.GetNumCameraDrivers(); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => - Underlying.Value!.GetNumGamepadTouchpadFingers(gamepad, touchpad); + public static int AddAtomicInt(AtomicInt* a, int v) => Underlying.Value!.AddAtomicInt(a, v); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumGamepadTouchpads(GamepadHandle gamepad) => - Underlying.Value!.GetNumGamepadTouchpads(gamepad); + public static int AddAtomicInt(Ref a, int v) + { + fixed (AtomicInt* __dsl_a = a) + { + return (int)AddAtomicInt(__dsl_a, v); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumHapticAxes(HapticHandle haptic) => - Underlying.Value!.GetNumHapticAxes(haptic); + public static byte AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => Underlying.Value!.AddEventWatch(filter, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumJoystickAxes(JoystickHandle joystick) => - Underlying.Value!.GetNumJoystickAxes(joystick); + public static MaybeBool AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool)(byte)AddEventWatch(filter, __dsl_userdata); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumJoystickBalls(JoystickHandle joystick) => - Underlying.Value!.GetNumJoystickBalls(joystick); + public static int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => + Underlying.Value!.AddGamepadMapping(mapping); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumJoystickButtons(JoystickHandle joystick) => - Underlying.Value!.GetNumJoystickButtons(joystick); + public static int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) + { + fixed (sbyte* __dsl_mapping = mapping) + { + return (int)AddGamepadMapping(__dsl_mapping); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumJoystickHats(JoystickHandle joystick) => - Underlying.Value!.GetNumJoystickHats(joystick); + public static int AddGamepadMappingsFromFile( + [NativeTypeName("const char *")] sbyte* file + ) => Underlying.Value!.AddGamepadMappingsFromFile(file); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumLogicalCPUCores() => Underlying.Value!.GetNumLogicalCPUCores(); + public static int AddGamepadMappingsFromFile( + [NativeTypeName("const char *")] Ref file + ) + { + fixed (sbyte* __dsl_file = file) + { + return (int)AddGamepadMappingsFromFile(__dsl_file); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumRenderDrivers() => Underlying.Value!.GetNumRenderDrivers(); + public static int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio + ) => Underlying.Value!.AddGamepadMappingsFromIO(src, closeio); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetNumVideoDrivers() => Underlying.Value!.GetNumVideoDrivers(); + public static int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => Underlying.Value!.AddGamepadMappingsFromIO(src, closeio); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetPathInfo( - [NativeTypeName("const char *")] sbyte* path, - PathInfo* info - ) => Underlying.Value!.GetPathInfo(path, info); + public static byte AddHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => Underlying.Value!.AddHintCallback(name, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetPathInfo( - [NativeTypeName("const char *")] Ref path, - Ref info + public static MaybeBool AddHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata ) { - fixed (PathInfo* __dsl_info = info) - fixed (sbyte* __dsl_path = path) + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)GetPathInfo(__dsl_path, __dsl_info); + return (MaybeBool)(byte)AddHintCallback(__dsl_name, callback, __dsl_userdata); } } - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetPerformanceCounter() => Underlying.Value!.GetPerformanceCounter(); + public static byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => + Underlying.Value!.AddSurfaceAlternateImage(surface, image); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetPerformanceFrequency() => - Underlying.Value!.GetPerformanceFrequency(); + public static MaybeBool AddSurfaceAlternateImage( + Ref surface, + Ref image + ) + { + fixed (Surface* __dsl_image = image) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)AddSurfaceAlternateImage(__dsl_surface, __dsl_image); + } + } - [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + void* userdata + ) => Underlying.Value!.AddTimer(interval, callback, userdata); + + [return: NativeTypeName("SDL_TimerID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPixelFormatDetails(PixelFormat format) => - Underlying.Value!.GetPixelFormatDetails(format); + public static uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (uint)AddTimer(interval, callback, __dsl_userdata); + } + } - [return: NativeTypeName("const SDL_PixelFormatDetails *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => - Underlying.Value!.GetPixelFormatDetailsRaw(format); + public static uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + void* userdata + ) => Underlying.Value!.AddTimerNS(interval, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] + [return: NativeTypeName("SDL_TimerID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PixelFormat GetPixelFormatForMasks( - int bpp, - [NativeTypeName("Uint32")] uint Rmask, - [NativeTypeName("Uint32")] uint Gmask, - [NativeTypeName("Uint32")] uint Bmask, - [NativeTypeName("Uint32")] uint Amask - ) => Underlying.Value!.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); + public static uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (uint)AddTimerNS(interval, callback, __dsl_userdata); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPixelFormatName(PixelFormat format) => - Underlying.Value!.GetPixelFormatName(format); + public static MaybeBool AddVulkanRenderSemaphores( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + Underlying.Value!.AddVulkanRenderSemaphores( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetPixelFormatNameRaw(PixelFormat format) => - Underlying.Value!.GetPixelFormatNameRaw(format); + public static byte AddVulkanRenderSemaphoresRaw( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + Underlying.Value!.AddVulkanRenderSemaphoresRaw( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPlatform() => Underlying.Value!.GetPlatform(); + public static Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.AlignedAlloc(alignment, size); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetPlatformRaw() => Underlying.Value!.GetPlatformRaw(); + public static void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.AlignedAllocRaw(alignment, size); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* default_value - ) => Underlying.Value!.GetPointerProperty(props, name, default_value); + public static void AlignedFree(void* mem) => Underlying.Value!.AlignedFree(mem); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref default_value - ) + public static void AlignedFree(Ref mem) { - fixed (void* __dsl_default_value = default_value) - fixed (sbyte* __dsl_name = name) + fixed (void* __dsl_mem = mem) { - return (void*)GetPointerProperty(props, __dsl_name, __dsl_default_value); + AlignedFree(__dsl_mem); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_asin")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetPowerInfo(int* seconds, int* percent) => - Underlying.Value!.GetPowerInfo(seconds, percent); + public static double Asin(double x) => Underlying.Value!.Asin(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_asinf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Asinf(float x) => Underlying.Value!.Asinf(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Atan(double x) => Underlying.Value!.Atan(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Atan2(double y, double x) => Underlying.Value!.Atan2(y, x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atan2f")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Atan2F(float y, float x) => Underlying.Value!.Atan2F(y, x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atanf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Atanf(float x) => Underlying.Value!.Atanf(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Atof([NativeTypeName("const char *")] sbyte* str) => + Underlying.Value!.Atof(str); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PowerState GetPowerInfo(Ref seconds, Ref percent) + public static double Atof([NativeTypeName("const char *")] Ref str) { - fixed (int* __dsl_percent = percent) - fixed (int* __dsl_seconds = seconds) + fixed (sbyte* __dsl_str = str) { - return (PowerState)GetPowerInfo(__dsl_seconds, __dsl_percent); + return (double)Atof(__dsl_str); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Locale** GetPreferredLocales(int* count) => - Underlying.Value!.GetPreferredLocales(count); + public static int Atoi([NativeTypeName("const char *")] sbyte* str) => + Underlying.Value!.Atoi(str); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetPreferredLocales(Ref count) + public static int Atoi([NativeTypeName("const char *")] Ref str) { - fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_str = str) { - return (Locale**)GetPreferredLocales(__dsl_count); + return (int)Atoi(__dsl_str); } } - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetPrefPath( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app - ) => Underlying.Value!.GetPrefPath(org, app); + public static uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + ) => Underlying.Value!.AttachVirtualJoystick(desc); - [return: NativeTypeName("char *")] + [return: NativeTypeName("SDL_JoystickID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPrefPath( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app + public static uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc ) { - fixed (sbyte* __dsl_app = app) - fixed (sbyte* __dsl_org = org) + fixed (VirtualJoystickDesc* __dsl_desc = desc) { - return (sbyte*)GetPrefPath(__dsl_org, __dsl_app); + return (uint)AttachVirtualJoystick(__dsl_desc); } } - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetPrimaryDisplay() => Underlying.Value!.GetPrimaryDisplay(); + public static MaybeBool AudioDevicePaused( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => Underlying.Value!.AudioDevicePaused(dev); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + Underlying.Value!.AudioDevicePausedRaw(dev); + + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + Underlying.Value!.BeginGPUComputePass( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetPrimarySelectionText() => - Underlying.Value!.GetPrimarySelectionText(); + public static GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) + { + fixed ( + GPUStorageBufferReadWriteBinding* __dsl_storage_buffer_bindings = + storage_buffer_bindings + ) + fixed ( + GPUStorageTextureReadWriteBinding* __dsl_storage_texture_bindings = + storage_texture_bindings + ) + { + return (GPUComputePassHandle)BeginGPUComputePass( + command_buffer, + __dsl_storage_texture_bindings, + num_storage_texture_bindings, + __dsl_storage_buffer_bindings, + num_storage_buffer_bindings + ); + } + } - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUCopyPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetPrimarySelectionTextRaw() => - Underlying.Value!.GetPrimarySelectionTextRaw(); + public static GPUCopyPassHandle BeginGPUCopyPass(GPUCommandBufferHandle command_buffer) => + Underlying.Value!.BeginGPUCopyPass(command_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.GetPropertyType(props, name); + public static GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ) => + Underlying.Value!.BeginGPURenderPass( + command_buffer, + color_target_infos, + num_color_targets, + depth_stencil_target_info + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name + public static GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info ) { - fixed (sbyte* __dsl_name = name) + fixed ( + GPUDepthStencilTargetInfo* __dsl_depth_stencil_target_info = + depth_stencil_target_info + ) + fixed (GPUColorTargetInfo* __dsl_color_target_infos = color_target_infos) { - return (PropertyType)GetPropertyType(props, __dsl_name); + return (GPURenderPassHandle)BeginGPURenderPass( + command_buffer, + __dsl_color_target_infos, + num_color_targets, + __dsl_depth_stencil_target_info + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadType GetRealGamepadType(GamepadHandle gamepad) => - Underlying.Value!.GetRealGamepadType(gamepad); + public static MaybeBool BindAudioStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => Underlying.Value!.BindAudioStream(devid, stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadType GetRealGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.GetRealGamepadTypeForID(instance_id); + public static byte BindAudioStreamRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => Underlying.Value!.BindAudioStreamRaw(devid, stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int* X1, - int* Y1, - int* X2, - int* Y2 - ) => Underlying.Value!.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); + public static byte BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle* streams, + int num_streams + ) => Underlying.Value!.BindAudioStreams(devid, streams, num_streams); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 + public static MaybeBool BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref streams, + int num_streams ) { - fixed (int* __dsl_Y2 = Y2) - fixed (int* __dsl_X2 = X2) - fixed (int* __dsl_Y1 = Y1) - fixed (int* __dsl_X1 = X1) - fixed (Rect* __dsl_rect = rect) + fixed (AudioStreamHandle* __dsl_streams = streams) { - return (MaybeBool) - (byte)GetRectAndLineIntersection( - __dsl_rect, - __dsl_X1, - __dsl_Y1, - __dsl_X2, - __dsl_Y2 - ); + return (MaybeBool)(byte)BindAudioStreams(devid, __dsl_streams, num_streams); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* rect, - float* X1, - float* Y1, - float* X2, - float* Y2 - ) => Underlying.Value!.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); + public static void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ) => Underlying.Value!.BindGPUComputePipeline(compute_pass, compute_pipeline); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUComputeSamplers( + compute_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 + public static void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (float* __dsl_Y2 = Y2) - fixed (float* __dsl_X2 = X2) - fixed (float* __dsl_Y1 = Y1) - fixed (float* __dsl_X1 = X1) - fixed (FRect* __dsl_rect = rect) + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) { - return (MaybeBool) - (byte)GetRectAndLineIntersectionFloat( - __dsl_rect, - __dsl_X1, - __dsl_Y1, - __dsl_X2, - __dsl_Y2 - ); + BindGPUComputeSamplers( + compute_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Point* points, - int count, - [NativeTypeName("const SDL_Rect *")] Rect* clip, - Rect* result - ) => Underlying.Value!.GetRectEnclosingPoints(points, count, clip, result); + public static void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + storage_buffers, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Ref points, - int count, - [NativeTypeName("const SDL_Rect *")] Ref clip, - Ref result + public static void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_clip = clip) - fixed (Point* __dsl_points = points) + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) { - return (MaybeBool) - (byte)GetRectEnclosingPoints(__dsl_points, count, __dsl_clip, __dsl_result); + BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count, - [NativeTypeName("const SDL_FRect *")] FRect* clip, - FRect* result - ) => Underlying.Value!.GetRectEnclosingPointsFloat(points, count, clip, result); + public static void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUComputeStorageTextures( + compute_pass, + first_slot, + storage_textures, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count, - [NativeTypeName("const SDL_FRect *")] Ref clip, - Ref result + public static void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_clip = clip) - fixed (FPoint* __dsl_points = points) + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) { - return (MaybeBool) - (byte)GetRectEnclosingPointsFloat( - __dsl_points, - count, - __dsl_clip, - __dsl_result - ); + BindGPUComputeStorageTextures( + compute_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => Underlying.Value!.GetRectIntersection(A, B, result); + public static void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUFragmentSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result + public static void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) { - return (MaybeBool)(byte)GetRectIntersection(__dsl_A, __dsl_B, __dsl_result); + BindGPUFragmentSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => Underlying.Value!.GetRectIntersectionFloat(A, B, result); + public static void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result + public static void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) { - return (MaybeBool) - (byte)GetRectIntersectionFloat(__dsl_A, __dsl_B, __dsl_result); + BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => Underlying.Value!.GetRectUnion(A, B, result); + public static void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUFragmentStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result + public static void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) { - return (MaybeBool)(byte)GetRectUnion(__dsl_A, __dsl_B, __dsl_result); + BindGPUFragmentStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => Underlying.Value!.GetRectUnionFloat(A, B, result); + public static void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ) => Underlying.Value!.BindGPUGraphicsPipeline(render_pass, graphics_pipeline); + + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ) => Underlying.Value!.BindGPUIndexBuffer(render_pass, binding, index_element_size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result + public static void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size ) { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) + fixed (GPUBufferBinding* __dsl_binding = binding) { - return (MaybeBool)(byte)GetRectUnionFloat(__dsl_A, __dsl_B, __dsl_result); + BindGPUIndexBuffer(render_pass, __dsl_binding, index_element_size); } } - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetRelativeMouseState(float* x, float* y) => - Underlying.Value!.GetRelativeMouseState(x, y); + public static void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUVertexBuffers(render_pass, first_slot, bindings, num_bindings); - [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetRelativeMouseState(Ref x, Ref y) + public static void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) + fixed (GPUBufferBinding* __dsl_bindings = bindings) { - return (uint)GetRelativeMouseState(__dsl_x, __dsl_y); + BindGPUVertexBuffers(render_pass, first_slot, __dsl_bindings, num_bindings); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => - Underlying.Value!.GetRenderClipRect(renderer, rect); + public static void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUVertexSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) + public static void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) { - fixed (Rect* __dsl_rect = rect) + fixed ( + GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings + ) { - return (MaybeBool)(byte)GetRenderClipRect(renderer, __dsl_rect); + BindGPUVertexSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderColorScale(RendererHandle renderer, float* scale) => - Underlying.Value!.GetRenderColorScale(renderer, scale); + public static void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUVertexStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) + public static void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) { - fixed (float* __dsl_scale = scale) + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) { - return (MaybeBool)(byte)GetRenderColorScale(renderer, __dsl_scale); + BindGPUVertexStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => Underlying.Value!.GetRenderDrawBlendMode(renderer, blendMode); + public static void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + Underlying.Value!.BindGPUVertexStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode + public static void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings ) { - fixed (BlendMode* __dsl_blendMode = blendMode) + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) { - return (MaybeBool)(byte)GetRenderDrawBlendMode(renderer, __dsl_blendMode); + BindGPUVertexStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => Underlying.Value!.GetRenderDrawColor(renderer, r, g, b, a); + public static void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ) => Underlying.Value!.BlitGPUTexture(command_buffer, info); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a + public static void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info ) { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) + fixed (GPUBlitInfo* __dsl_info = info) { - return (MaybeBool) - (byte)GetRenderDrawColor(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); + BlitGPUTexture(command_buffer, __dsl_info); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderDrawColorFloat( - RendererHandle renderer, - float* r, - float* g, - float* b, - float* a - ) => Underlying.Value!.GetRenderDrawColorFloat(renderer, r, g, b, a); + public static byte BlitSurface( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => Underlying.Value!.BlitSurface(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderDrawColorFloat( - RendererHandle renderer, - Ref r, - Ref g, - Ref b, - Ref a + public static MaybeBool BlitSurface( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect ) { - fixed (float* __dsl_a = a) - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) { return (MaybeBool) - (byte)GetRenderDrawColorFloat(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); + (byte)BlitSurface(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); } } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr GetRenderDriver(int index) => - Underlying.Value!.GetRenderDriver(index); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static sbyte* GetRenderDriverRaw(int index) => - Underlying.Value!.GetRenderDriverRaw(index); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static RendererHandle GetRenderer(WindowHandle window) => - Underlying.Value!.GetRenderer(window); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle GetRendererFromTexture(Texture* texture) => - Underlying.Value!.GetRendererFromTexture(texture); + public static byte BlitSurface9Grid( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + Underlying.Value!.BlitSurface9Grid( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static RendererHandle GetRendererFromTexture(Ref texture) + public static MaybeBool BlitSurface9Grid( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) { - fixed (Texture* __dsl_texture = texture) + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) { - return (RendererHandle)GetRendererFromTexture(__dsl_texture); + return (MaybeBool) + (byte)BlitSurface9Grid( + __dsl_src, + __dsl_srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + __dsl_dst, + __dsl_dstrect + ); } } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr GetRendererName(RendererHandle renderer) => - Underlying.Value!.GetRendererName(renderer); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetRendererNameRaw(RendererHandle renderer) => - Underlying.Value!.GetRendererNameRaw(renderer); + public static byte BlitSurfaceScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => Underlying.Value!.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetRendererProperties(RendererHandle renderer) => - Underlying.Value!.GetRendererProperties(renderer); + public static MaybeBool BlitSurfaceScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte)BlitSurfaceScaled( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect, + scaleMode + ); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderLogicalPresentation( - RendererHandle renderer, - int* w, - int* h, - RendererLogicalPresentation* mode - ) => Underlying.Value!.GetRenderLogicalPresentation(renderer, w, h, mode); + public static byte BlitSurfaceTiled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => Underlying.Value!.BlitSurfaceTiled(src, srcrect, dst, dstrect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderLogicalPresentation( - RendererHandle renderer, - Ref w, - Ref h, - Ref mode + public static MaybeBool BlitSurfaceTiled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect ) { - fixed (RendererLogicalPresentation* __dsl_mode = mode) - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) { return (MaybeBool) - (byte)GetRenderLogicalPresentation(renderer, __dsl_w, __dsl_h, __dsl_mode); + (byte)BlitSurfaceTiled(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => - Underlying.Value!.GetRenderLogicalPresentationRect(renderer, rect); + public static byte BlitSurfaceTiledWithScale( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + Underlying.Value!.BlitSurfaceTiledWithScale( + src, + srcrect, + scale, + scaleMode, + dst, + dstrect + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderLogicalPresentationRect( - RendererHandle renderer, - Ref rect + public static MaybeBool BlitSurfaceTiledWithScale( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect ) { - fixed (FRect* __dsl_rect = rect) + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) { return (MaybeBool) - (byte)GetRenderLogicalPresentationRect(renderer, __dsl_rect); + (byte)BlitSurfaceTiledWithScale( + __dsl_src, + __dsl_srcrect, + scale, + scaleMode, + __dsl_dst, + __dsl_dstrect + ); } } - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => - Underlying.Value!.GetRenderMetalCommandEncoder(renderer); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => - Underlying.Value!.GetRenderMetalCommandEncoderRaw(renderer); + public static byte BlitSurfaceUnchecked( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => Underlying.Value!.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr GetRenderMetalLayer(RendererHandle renderer) => - Underlying.Value!.GetRenderMetalLayer(renderer); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetRenderMetalLayerRaw(RendererHandle renderer) => - Underlying.Value!.GetRenderMetalLayerRaw(renderer); + public static MaybeBool BlitSurfaceUnchecked( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte)BlitSurfaceUnchecked(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => - Underlying.Value!.GetRenderOutputSize(renderer, w, h); + public static byte BlitSurfaceUncheckedScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => Underlying.Value!.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h + public static MaybeBool BlitSurfaceUncheckedScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) { - return (MaybeBool)(byte)GetRenderOutputSize(renderer, __dsl_w, __dsl_h); + return (MaybeBool) + (byte)BlitSurfaceUncheckedScaled( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect, + scaleMode + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => - Underlying.Value!.GetRenderSafeArea(renderer, rect); + public static void BroadcastCondition(ConditionHandle cond) => + Underlying.Value!.BroadcastCondition(cond); + + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => Underlying.Value!.Bsearch(key, @base, nmemb, size, compare); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) + public static Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) { - fixed (Rect* __dsl_rect = rect) + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) { - return (MaybeBool)(byte)GetRenderSafeArea(renderer, __dsl_rect); + return (void*)Bsearch(__dsl_key, __dsl_base, nmemb, size, compare); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => - Underlying.Value!.GetRenderScale(renderer, scaleX, scaleY); + public static void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => Underlying.Value!.BsearchR(key, @base, nmemb, size, compare, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderScale( - RendererHandle renderer, - Ref scaleX, - Ref scaleY + public static Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata ) { - fixed (float* __dsl_scaleY = scaleY) - fixed (float* __dsl_scaleX = scaleX) + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) { - return (MaybeBool)(byte)GetRenderScale(renderer, __dsl_scaleX, __dsl_scaleY); + return (void*)BsearchR(__dsl_key, __dsl_base, nmemb, size, compare, __dsl_userdata); } } - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CalculateGPUTextureFormatSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetRenderTarget(RendererHandle renderer) => - Underlying.Value!.GetRenderTarget(renderer); + public static uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ) => + Underlying.Value!.CalculateGPUTextureFormatSize( + format, + width, + height, + depth_or_layer_count + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Texture* GetRenderTargetRaw(RendererHandle renderer) => - Underlying.Value!.GetRenderTargetRaw(renderer); + public static Ptr Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.Calloc(nmemb, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderViewport(RendererHandle renderer, Rect* rect) => - Underlying.Value!.GetRenderViewport(renderer, rect); + public static void* CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.CallocRaw(nmemb, size); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)GetRenderViewport(renderer, __dsl_rect); - } - } + public static MaybeBool CancelGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ) => Underlying.Value!.CancelGPUCommandBuffer(command_buffer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetRenderVSync(RendererHandle renderer, int* vsync) => - Underlying.Value!.GetRenderVSync(renderer, vsync); + public static byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + Underlying.Value!.CancelGPUCommandBufferRaw(command_buffer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) - { - fixed (int* __dsl_vsync = vsync) - { - return (MaybeBool)(byte)GetRenderVSync(renderer, __dsl_vsync); - } - } - - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetRenderWindow(RendererHandle renderer) => - Underlying.Value!.GetRenderWindow(renderer); + public static byte CaptureMouse([NativeTypeName("bool")] byte enabled) => + Underlying.Value!.CaptureMouse(enabled); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetRevision() => Underlying.Value!.GetRevision(); + public static MaybeBool CaptureMouse( + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.CaptureMouse(enabled); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [NativeFunction("SDL3", EntryPoint = "SDL_ceil")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetRevisionRaw() => Underlying.Value!.GetRevisionRaw(); + public static double Ceil(double x) => Underlying.Value!.Ceil(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_ceilf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => Underlying.Value!.GetRGB(pixel, format, palette, r, g, b); + public static float Ceilf(float x) => Underlying.Value!.Ceilf(x); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) - { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) - { - GetRGB(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b); - } - } + public static MaybeBool ClaimWindowForGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ) => Underlying.Value!.ClaimWindowForGPUDevice(device, window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => Underlying.Value!.GetRgba(pixel, format, palette, r, g, b, a); + public static byte ClaimWindowForGPUDeviceRaw( + GPUDeviceHandle device, + WindowHandle window + ) => Underlying.Value!.ClaimWindowForGPUDeviceRaw(device, window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) - { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) - { - GetRgba(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b, __dsl_a); - } - } + public static void CleanupTLS() => Underlying.Value!.CleanupTLS(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Sandbox GetSandbox() => Underlying.Value!.GetSandbox(); + public static MaybeBool ClearAudioStream(AudioStreamHandle stream) => + Underlying.Value!.ClearAudioStream(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] ushort* modstate - ) => Underlying.Value!.GetScancodeFromKey(key, modstate); + public static byte ClearAudioStreamRaw(AudioStreamHandle stream) => + Underlying.Value!.ClearAudioStreamRaw(stream); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] Ref modstate - ) - { - fixed (ushort* __dsl_modstate = modstate) - { - return (Scancode)GetScancodeFromKey(key, __dsl_modstate); - } - } + public static MaybeBool ClearClipboardData() => + Underlying.Value!.ClearClipboardData(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => - Underlying.Value!.GetScancodeFromName(name); + public static byte ClearClipboardDataRaw() => Underlying.Value!.ClearClipboardDataRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) - { - fixed (sbyte* __dsl_name = name) - { - return (Scancode)GetScancodeFromName(__dsl_name); - } - } + public static MaybeBool ClearComposition(WindowHandle window) => + Underlying.Value!.ClearComposition(window); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetScancodeName(Scancode scancode) => - Underlying.Value!.GetScancodeName(scancode); + public static byte ClearCompositionRaw(WindowHandle window) => + Underlying.Value!.ClearCompositionRaw(window); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetScancodeNameRaw(Scancode scancode) => - Underlying.Value!.GetScancodeNameRaw(scancode); + public static MaybeBool ClearError() => Underlying.Value!.ClearError(); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetSemaphoreValue(SemaphoreHandle sem) => - Underlying.Value!.GetSemaphoreValue(sem); + public static byte ClearErrorRaw() => Underlying.Value!.ClearErrorRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSensorData(SensorHandle sensor, float* data, int num_values) => - Underlying.Value!.GetSensorData(sensor, data, num_values); + public static byte ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.ClearProperty(props, name); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSensorData( - SensorHandle sensor, - Ref data, - int num_values + public static MaybeBool ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name ) { - fixed (float* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)GetSensorData(sensor, __dsl_data, num_values); + return (MaybeBool)(byte)ClearProperty(props, __dsl_name); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static SensorHandle GetSensorFromID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => Underlying.Value!.GetSensorFromID(instance_id); - - [return: NativeTypeName("SDL_SensorID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetSensorID(SensorHandle sensor) => - Underlying.Value!.GetSensorID(sensor); + public static byte ClearSurface(Surface* surface, float r, float g, float b, float a) => + Underlying.Value!.ClearSurface(surface, r, g, b, a); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetSensorName(SensorHandle sensor) => - Underlying.Value!.GetSensorName(sensor); + public static MaybeBool ClearSurface( + Ref surface, + float r, + float g, + float b, + float a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)ClearSurface(__dsl_surface, r, g, b, a); + } + } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetSensorNameForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => Underlying.Value!.GetSensorNameForID(instance_id); + public static void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + Underlying.Value!.CloseAudioDevice(devid); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetSensorNameForIDRaw( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => Underlying.Value!.GetSensorNameForIDRaw(instance_id); + public static void CloseCamera(CameraHandle camera) => + Underlying.Value!.CloseCamera(camera); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetSensorNameRaw(SensorHandle sensor) => - Underlying.Value!.GetSensorNameRaw(sensor); + public static void CloseGamepad(GamepadHandle gamepad) => + Underlying.Value!.CloseGamepad(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetSensorNonPortableType(SensorHandle sensor) => - Underlying.Value!.GetSensorNonPortableType(sensor); + public static void CloseHaptic(HapticHandle haptic) => + Underlying.Value!.CloseHaptic(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetSensorNonPortableTypeForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => Underlying.Value!.GetSensorNonPortableTypeForID(instance_id); + public static MaybeBool CloseIO(IOStreamHandle context) => + Underlying.Value!.CloseIO(context); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetSensorProperties(SensorHandle sensor) => - Underlying.Value!.GetSensorProperties(sensor); + public static byte CloseIORaw(IOStreamHandle context) => + Underlying.Value!.CloseIORaw(context); - [return: NativeTypeName("SDL_SensorID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint* GetSensors(int* count) => Underlying.Value!.GetSensors(count); + public static void CloseJoystick(JoystickHandle joystick) => + Underlying.Value!.CloseJoystick(joystick); - [return: NativeTypeName("SDL_SensorID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetSensors(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)GetSensors(__dsl_count); - } - } + public static void CloseSensor(SensorHandle sensor) => + Underlying.Value!.CloseSensor(sensor); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SensorType GetSensorType(SensorHandle sensor) => - Underlying.Value!.GetSensorType(sensor); + public static MaybeBool CloseStorage(StorageHandle storage) => + Underlying.Value!.CloseStorage(storage); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SensorType GetSensorTypeForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => Underlying.Value!.GetSensorTypeForID(instance_id); + public static byte CloseStorageRaw(StorageHandle storage) => + Underlying.Value!.CloseStorageRaw(storage); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetSilenceValueForFormat(AudioFormat format) => - Underlying.Value!.GetSilenceValueForFormat(format); + public static byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => + Underlying.Value!.CompareAndSwapAtomicInt(a, oldval, newval); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint GetSimdAlignment() => Underlying.Value!.GetSimdAlignment(); + public static MaybeBool CompareAndSwapAtomicInt( + Ref a, + int oldval, + int newval + ) + { + fixed (AtomicInt* __dsl_a = a) + { + return (MaybeBool)(byte)CompareAndSwapAtomicInt(__dsl_a, oldval, newval); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("Uint64 *")] ulong* length - ) => Underlying.Value!.GetStorageFileSize(storage, path, length); + public static byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => + Underlying.Value!.CompareAndSwapAtomicPointer(a, oldval, newval); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("Uint64 *")] Ref length - ) + public static MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) { - fixed (ulong* __dsl_length = length) - fixed (sbyte* __dsl_path = path) + fixed (void* __dsl_newval = newval) + fixed (void* __dsl_oldval = oldval) + fixed (void** __dsl_a = a) { - return (MaybeBool)(byte)GetStorageFileSize(storage, __dsl_path, __dsl_length); + return (MaybeBool) + (byte)CompareAndSwapAtomicPointer(__dsl_a, __dsl_oldval, __dsl_newval); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - PathInfo* info - ) => Underlying.Value!.GetStoragePathInfo(storage, path, info); + public static byte CompareAndSwapAtomicU32( + AtomicU32* a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => Underlying.Value!.CompareAndSwapAtomicU32(a, oldval, newval); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref info + public static MaybeBool CompareAndSwapAtomicU32( + Ref a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval ) { - fixed (PathInfo* __dsl_info = info) - fixed (sbyte* __dsl_path = path) + fixed (AtomicU32* __dsl_a = a) { - return (MaybeBool)(byte)GetStoragePathInfo(storage, __dsl_path, __dsl_info); + return (MaybeBool)(byte)CompareAndSwapAtomicU32(__dsl_a, oldval, newval); } } - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] + [return: NativeTypeName("SDL_BlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetStorageSpaceRemaining(StorageHandle storage) => - Underlying.Value!.GetStorageSpaceRemaining(storage); + public static uint ComposeCustomBlendMode( + BlendFactor srcColorFactor, + BlendFactor dstColorFactor, + BlendOperation colorOperation, + BlendFactor srcAlphaFactor, + BlendFactor dstAlphaFactor, + BlendOperation alphaOperation + ) => + Underlying.Value!.ComposeCustomBlendMode( + srcColorFactor, + dstColorFactor, + colorOperation, + srcAlphaFactor, + dstAlphaFactor, + alphaOperation + ); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* default_value - ) => Underlying.Value!.GetStringProperty(props, name, default_value); + public static byte ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const Uint8 *")] byte* src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, + [NativeTypeName("Uint8 **")] byte** dst_data, + int* dst_len + ) => + Underlying.Value!.ConvertAudioSamples( + src_spec, + src_data, + src_len, + dst_spec, + dst_data, + dst_len + ); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref default_value + public static MaybeBool ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const Uint8 *")] Ref src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, + [NativeTypeName("Uint8 **")] Ref2D dst_data, + Ref dst_len ) { - fixed (sbyte* __dsl_default_value = default_value) - fixed (sbyte* __dsl_name = name) + fixed (int* __dsl_dst_len = dst_len) + fixed (byte** __dsl_dst_data = dst_data) + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (byte* __dsl_src_data = src_data) + fixed (AudioSpec* __dsl_src_spec = src_spec) { - return (sbyte*)GetStringProperty(props, __dsl_name, __dsl_default_value); + return (MaybeBool) + (byte)ConvertAudioSamples( + __dsl_src_spec, + __dsl_src_data, + src_len, + __dsl_dst_spec, + __dsl_dst_data, + __dsl_dst_len + ); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSurfaceAlphaMod( - Surface* surface, - [NativeTypeName("Uint8 *")] byte* alpha - ) => Underlying.Value!.GetSurfaceAlphaMod(surface, alpha); + public static byte ConvertEventToRenderCoordinates( + RendererHandle renderer, + Event* @event + ) => Underlying.Value!.ConvertEventToRenderCoordinates(renderer, @event); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref alpha + public static MaybeBool ConvertEventToRenderCoordinates( + RendererHandle renderer, + Ref @event ) { - fixed (byte* __dsl_alpha = alpha) - fixed (Surface* __dsl_surface = surface) + fixed (Event* __dsl_event = @event) { - return (MaybeBool)(byte)GetSurfaceAlphaMod(__dsl_surface, __dsl_alpha); + return (MaybeBool) + (byte)ConvertEventToRenderCoordinates(renderer, __dsl_event); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => Underlying.Value!.GetSurfaceBlendMode(surface, blendMode); + public static byte ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch + ) => + Underlying.Value!.ConvertPixels( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode + public static MaybeBool ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch ) { - fixed (BlendMode* __dsl_blendMode = blendMode) - fixed (Surface* __dsl_surface = surface) + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) { - return (MaybeBool)(byte)GetSurfaceBlendMode(__dsl_surface, __dsl_blendMode); + return (MaybeBool) + (byte)ConvertPixels( + width, + height, + src_format, + __dsl_src, + src_pitch, + dst_format, + __dsl_dst, + dst_pitch + ); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSurfaceClipRect(Surface* surface, Rect* rect) => - Underlying.Value!.GetSurfaceClipRect(surface, rect); + public static byte ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + void* dst, + int dst_pitch + ) => + Underlying.Value!.ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) + public static MaybeBool ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + Ref dst, + int dst_pitch + ) { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_surface = surface) + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) { - return (MaybeBool)(byte)GetSurfaceClipRect(__dsl_surface, __dsl_rect); + return (MaybeBool) + (byte)ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + __dsl_src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + __dsl_dst, + dst_pitch + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSurfaceColorKey( - Surface* surface, - [NativeTypeName("Uint32 *")] uint* key - ) => Underlying.Value!.GetSurfaceColorKey(surface, key); + public static Surface* ConvertSurface(Surface* surface, PixelFormat format) => + Underlying.Value!.ConvertSurface(surface, format); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSurfaceColorKey( - Ref surface, - [NativeTypeName("Uint32 *")] Ref key - ) + public static Ptr ConvertSurface(Ref surface, PixelFormat format) { - fixed (uint* __dsl_key = key) fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)GetSurfaceColorKey(__dsl_surface, __dsl_key); + return (Surface*)ConvertSurface(__dsl_surface, format); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetSurfaceColorMod( + public static Surface* ConvertSurfaceAndColorspace( Surface* surface, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => Underlying.Value!.GetSurfaceColorMod(surface, r, g, b); + PixelFormat format, + Palette* palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + Underlying.Value!.ConvertSurfaceAndColorspace( + surface, + format, + palette, + colorspace, + props + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetSurfaceColorMod( + public static Ptr ConvertSurfaceAndColorspace( Ref surface, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b + PixelFormat format, + Ref palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props ) { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) + fixed (Palette* __dsl_palette = palette) fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte)GetSurfaceColorMod(__dsl_surface, __dsl_r, __dsl_g, __dsl_b); + return (Surface*)ConvertSurfaceAndColorspace( + __dsl_surface, + format, + __dsl_palette, + colorspace, + props + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Colorspace GetSurfaceColorspace(Surface* surface) => - Underlying.Value!.GetSurfaceColorspace(surface); + public static byte CopyFile( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => Underlying.Value!.CopyFile(oldpath, newpath); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Colorspace GetSurfaceColorspace(Ref surface) + public static MaybeBool CopyFile( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) { - return (Colorspace)GetSurfaceColorspace(__dsl_surface); + return (MaybeBool)(byte)CopyFile(__dsl_oldpath, __dsl_newpath); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface** GetSurfaceImages(Surface* surface, int* count) => - Underlying.Value!.GetSurfaceImages(surface, count); + public static void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ) => Underlying.Value!.CopyGPUBufferToBuffer(copy_pass, source, destination, size, cycle); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetSurfaceImages(Ref surface, Ref count) + public static void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ) { - fixed (int* __dsl_count = count) - fixed (Surface* __dsl_surface = surface) + fixed (GPUBufferLocation* __dsl_destination = destination) + fixed (GPUBufferLocation* __dsl_source = source) { - return (Surface**)GetSurfaceImages(__dsl_surface, __dsl_count); + CopyGPUBufferToBuffer( + copy_pass, + __dsl_source, + __dsl_destination, + size, + (byte)cycle + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Palette* GetSurfacePalette(Surface* surface) => - Underlying.Value!.GetSurfacePalette(surface); + public static void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ) => + Underlying.Value!.CopyGPUTextureToTexture( + copy_pass, + source, + destination, + w, + h, + d, + cycle + ); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetSurfacePalette(Ref surface) + public static void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ) { - fixed (Surface* __dsl_surface = surface) + fixed (GPUTextureLocation* __dsl_destination = destination) + fixed (GPUTextureLocation* __dsl_source = source) { - return (Palette*)GetSurfacePalette(__dsl_surface); + CopyGPUTextureToTexture( + copy_pass, + __dsl_source, + __dsl_destination, + w, + h, + d, + (byte)cycle + ); } } - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetSurfaceProperties(Surface* surface) => - Underlying.Value!.GetSurfaceProperties(surface); + public static MaybeBool CopyProperties( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => Underlying.Value!.CopyProperties(src, dst); - [return: NativeTypeName("SDL_PropertiesID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetSurfaceProperties(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (uint)GetSurfaceProperties(__dsl_surface); - } - } + public static byte CopyPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => Underlying.Value!.CopyPropertiesRaw(src, dst); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] + [NativeFunction("SDL3", EntryPoint = "SDL_copysign")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetSystemRAM() => Underlying.Value!.GetSystemRAM(); + public static double Copysign(double x, double y) => Underlying.Value!.Copysign(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] + [NativeFunction("SDL3", EntryPoint = "SDL_copysignf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SystemTheme GetSystemTheme() => Underlying.Value!.GetSystemTheme(); + public static float Copysignf(float x, float y) => Underlying.Value!.Copysignf(x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => - Underlying.Value!.GetTextInputArea(window, rect, cursor); + public static byte CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => Underlying.Value!.CopyStorageFile(storage, oldpath, newpath); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextInputArea( - WindowHandle window, - Ref rect, - Ref cursor + public static MaybeBool CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath ) { - fixed (int* __dsl_cursor = cursor) - fixed (Rect* __dsl_rect = rect) + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) { - return (MaybeBool)(byte)GetTextInputArea(window, __dsl_rect, __dsl_cursor); + return (MaybeBool) + (byte)CopyStorageFile(storage, __dsl_oldpath, __dsl_newpath); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_cos")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureAlphaMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* alpha - ) => Underlying.Value!.GetTextureAlphaMod(texture, alpha); + public static double Cos(double x) => Underlying.Value!.Cos(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_cosf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref alpha - ) - { - fixed (byte* __dsl_alpha = alpha) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool)(byte)GetTextureAlphaMod(__dsl_texture, __dsl_alpha); - } - } + public static float Cosf(float x) => Underlying.Value!.Cosf(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => - Underlying.Value!.GetTextureAlphaModFloat(texture, alpha); + public static ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => Underlying.Value!.Crc16(crc, data, len); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint16")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureAlphaModFloat( - Ref texture, - Ref alpha + public static ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len ) { - fixed (float* __dsl_alpha = alpha) - fixed (Texture* __dsl_texture = texture) + fixed (void* __dsl_data = data) { - return (MaybeBool)(byte)GetTextureAlphaModFloat(__dsl_texture, __dsl_alpha); + return (ushort)Crc16(crc, __dsl_data, len); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => Underlying.Value!.GetTextureBlendMode(texture, blendMode); + public static uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => Underlying.Value!.Crc32(crc, data, len); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode + public static uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len ) { - fixed (BlendMode* __dsl_blendMode = blendMode) - fixed (Texture* __dsl_texture = texture) + fixed (void* __dsl_data = data) { - return (MaybeBool)(byte)GetTextureBlendMode(__dsl_texture, __dsl_blendMode); + return (uint)Crc32(crc, __dsl_data, len); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => Underlying.Value!.GetTextureColorMod(texture, r, g, b); + public static AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => Underlying.Value!.CreateAudioStream(src_spec, dst_spec); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b + public static AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec ) { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Texture* __dsl_texture = texture) + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) { - return (MaybeBool) - (byte)GetTextureColorMod(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); + return (AudioStreamHandle)CreateAudioStream(__dsl_src_spec, __dsl_dst_spec); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureColorModFloat( - Texture* texture, - float* r, - float* g, - float* b - ) => Underlying.Value!.GetTextureColorModFloat(texture, r, g, b); + public static CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => + Underlying.Value!.CreateColorCursor(surface, hot_x, hot_y); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureColorModFloat( - Ref texture, - Ref r, - Ref g, - Ref b - ) + public static CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) { - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) - fixed (Texture* __dsl_texture = texture) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte)GetTextureColorModFloat(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); + return (CursorHandle)CreateColorCursor(__dsl_surface, hot_x, hot_y); } } - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static uint GetTextureProperties(Texture* texture) => - Underlying.Value!.GetTextureProperties(texture); - - [return: NativeTypeName("SDL_PropertiesID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetTextureProperties(Ref texture) - { - fixed (Texture* __dsl_texture = texture) - { - return (uint)GetTextureProperties(__dsl_texture); - } - } + public static ConditionHandle CreateCondition() => Underlying.Value!.CreateCondition(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => - Underlying.Value!.GetTextureScaleMode(texture, scaleMode); + public static CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] byte* data, + [NativeTypeName("const Uint8 *")] byte* mask, + int w, + int h, + int hot_x, + int hot_y + ) => Underlying.Value!.CreateCursor(data, mask, w, h, hot_x, hot_y); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureScaleMode( - Ref texture, - Ref scaleMode + public static CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] Ref data, + [NativeTypeName("const Uint8 *")] Ref mask, + int w, + int h, + int hot_x, + int hot_y ) { - fixed (ScaleMode* __dsl_scaleMode = scaleMode) - fixed (Texture* __dsl_texture = texture) + fixed (byte* __dsl_mask = mask) + fixed (byte* __dsl_data = data) { - return (MaybeBool)(byte)GetTextureScaleMode(__dsl_texture, __dsl_scaleMode); + return (CursorHandle)CreateCursor(__dsl_data, __dsl_mask, w, h, hot_x, hot_y); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetTextureSize(Texture* texture, float* w, float* h) => - Underlying.Value!.GetTextureSize(texture, w, h); + public static byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.CreateDirectory(path); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetTextureSize( - Ref texture, - Ref w, - Ref h + public static MaybeBool CreateDirectory( + [NativeTypeName("const char *")] Ref path ) { - fixed (float* __dsl_h = h) - fixed (float* __dsl_w = w) - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_path = path) { - return (MaybeBool)(byte)GetTextureSize(__dsl_texture, __dsl_w, __dsl_h); + return (MaybeBool)(byte)CreateDirectory(__dsl_path); } } - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetThreadID(ThreadHandle thread) => - Underlying.Value!.GetThreadID(thread); + public static EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] byte populated + ) => Underlying.Value!.CreateEnvironment(populated); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static Ptr GetThreadName(ThreadHandle thread) => - Underlying.Value!.GetThreadName(thread); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetThreadNameRaw(ThreadHandle thread) => - Underlying.Value!.GetThreadNameRaw(thread); + public static EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] MaybeBool populated + ) => Underlying.Value!.CreateEnvironment(populated); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetTicks() => Underlying.Value!.GetTicks(); + public static GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUBuffer(device, createinfo); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetTicksNS() => Underlying.Value!.GetTicksNS(); + public static GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ) + { + fixed (GPUBufferCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUBufferHandle)CreateGPUBuffer(device, __dsl_createinfo); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => - Underlying.Value!.GetTLS(id); + public static GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUComputePipeline(device, createinfo); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) + public static GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ) { - fixed (AtomicInt* __dsl_id = id) + fixed (GPUComputePipelineCreateInfo* __dsl_createinfo = createinfo) { - return (void*)GetTLS(__dsl_id); + return (GPUComputePipelineHandle)CreateGPUComputePipeline(device, __dsl_createinfo); } } - [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.CreateGPUDevice(format_flags, debug_mode, name); + [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetTouchDeviceName( - [NativeTypeName("SDL_TouchID")] ulong touchID - ) => Underlying.Value!.GetTouchDeviceName(touchID); + public static GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (GPUDeviceHandle)CreateGPUDevice(format_flags, (byte)debug_mode, __dsl_name); + } + } - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDeviceWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => - Underlying.Value!.GetTouchDeviceNameRaw(touchID); + public static GPUDeviceHandle CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateGPUDeviceWithProperties(props); - [return: NativeTypeName("SDL_TouchID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong* GetTouchDevices(int* count) => - Underlying.Value!.GetTouchDevices(count); + public static GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUGraphicsPipeline(device, createinfo); - [return: NativeTypeName("SDL_TouchID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetTouchDevices(Ref count) + public static GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ) { - fixed (int* __dsl_count = count) + fixed (GPUGraphicsPipelineCreateInfo* __dsl_createinfo = createinfo) { - return (ulong*)GetTouchDevices(__dsl_count); + return (GPUGraphicsPipelineHandle)CreateGPUGraphicsPipeline( + device, + __dsl_createinfo + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static TouchDeviceType GetTouchDeviceType( - [NativeTypeName("SDL_TouchID")] ulong touchID - ) => Underlying.Value!.GetTouchDeviceType(touchID); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Finger** GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - int* count - ) => Underlying.Value!.GetTouchFingers(touchID, count); + public static GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUSampler(device, createinfo); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - Ref count + public static GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] + Ref createinfo ) { - fixed (int* __dsl_count = count) + fixed (GPUSamplerCreateInfo* __dsl_createinfo = createinfo) { - return (Finger**)GetTouchFingers(touchID, __dsl_count); + return (GPUSamplerHandle)CreateGPUSampler(device, __dsl_createinfo); } } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetUserFolder(Folder folder) => - Underlying.Value!.GetUserFolder(folder); + public static GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUShader(device, createinfo); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetUserFolderRaw(Folder folder) => - Underlying.Value!.GetUserFolderRaw(folder); + public static GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ) + { + fixed (GPUShaderCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUShaderHandle)CreateGPUShader(device, __dsl_createinfo); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int GetVersion() => Underlying.Value!.GetVersion(); + public static GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUTexture(device, createinfo); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetVideoDriver(int index) => - Underlying.Value!.GetVideoDriver(index); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static sbyte* GetVideoDriverRaw(int index) => - Underlying.Value!.GetVideoDriverRaw(index); + public static GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUTextureCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUTextureHandle)CreateGPUTexture(device, __dsl_createinfo); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowAspectRatio( - WindowHandle window, - float* min_aspect, - float* max_aspect - ) => Underlying.Value!.GetWindowAspectRatio(window, min_aspect, max_aspect); + public static GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ) => Underlying.Value!.CreateGPUTransferBuffer(device, createinfo); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowAspectRatio( - WindowHandle window, - Ref min_aspect, - Ref max_aspect + public static GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo ) { - fixed (float* __dsl_max_aspect = max_aspect) - fixed (float* __dsl_min_aspect = min_aspect) + fixed (GPUTransferBufferCreateInfo* __dsl_createinfo = createinfo) { - return (MaybeBool) - (byte)GetWindowAspectRatio(window, __dsl_min_aspect, __dsl_max_aspect); + return (GPUTransferBufferHandle)CreateGPUTransferBuffer(device, __dsl_createinfo); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowBordersSize( - WindowHandle window, - int* top, - int* left, - int* bottom, - int* right - ) => Underlying.Value!.GetWindowBordersSize(window, top, left, bottom, right); + public static int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => Underlying.Value!.CreateHapticEffect(haptic, effect); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowBordersSize( - WindowHandle window, - Ref top, - Ref left, - Ref bottom, - Ref right + public static int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect ) { - fixed (int* __dsl_right = right) - fixed (int* __dsl_bottom = bottom) - fixed (int* __dsl_left = left) - fixed (int* __dsl_top = top) + fixed (HapticEffect* __dsl_effect = effect) { - return (MaybeBool) - (byte)GetWindowBordersSize( - window, - __dsl_top, - __dsl_left, - __dsl_bottom, - __dsl_right - ); + return (int)CreateHapticEffect(haptic, __dsl_effect); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetWindowDisplayScale(WindowHandle window) => - Underlying.Value!.GetWindowDisplayScale(window); + public static MutexHandle CreateMutex() => Underlying.Value!.CreateMutex(); - [return: NativeTypeName("SDL_WindowFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static ulong GetWindowFlags(WindowHandle window) => - Underlying.Value!.GetWindowFlags(window); + public static Ptr CreatePalette(int ncolors) => + Underlying.Value!.CreatePalette(ncolors); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Event* @event - ) => Underlying.Value!.GetWindowFromEvent(@event); + public static Palette* CreatePaletteRaw(int ncolors) => + Underlying.Value!.CreatePaletteRaw(ncolors); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static WindowHandle CreatePopupWindow( + WindowHandle parent, + int offset_x, + int offset_y, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => Underlying.Value!.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); + + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ) => Underlying.Value!.CreateProcess(args, pipe_stdio); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Ref @event + public static ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio ) { - fixed (Event* __dsl_event = @event) + fixed (sbyte** __dsl_args = args) { - return (WindowHandle)GetWindowFromEvent(__dsl_event); + return (ProcessHandle)CreateProcess(__dsl_args, (byte)pipe_stdio); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => - Underlying.Value!.GetWindowFromID(id); - - [return: NativeTypeName("const SDL_DisplayMode *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcessWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindowFullscreenMode(WindowHandle window) => - Underlying.Value!.GetWindowFullscreenMode(window); + public static ProcessHandle CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateProcessWithProperties(props); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => - Underlying.Value!.GetWindowFullscreenModeRaw(window); + public static uint CreateProperties() => Underlying.Value!.CreateProperties(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* GetWindowICCProfile( + public static RendererHandle CreateRenderer( WindowHandle window, - [NativeTypeName("size_t *")] nuint* size - ) => Underlying.Value!.GetWindowICCProfile(window, size); + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.CreateRenderer(window, name); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindowICCProfile( + public static RendererHandle CreateRenderer( WindowHandle window, - [NativeTypeName("size_t *")] Ref size + [NativeTypeName("const char *")] Ref name ) { - fixed (nuint* __dsl_size = size) + fixed (sbyte* __dsl_name = name) { - return (void*)GetWindowICCProfile(window, __dsl_size); + return (RendererHandle)CreateRenderer(window, __dsl_name); } } - [return: NativeTypeName("SDL_WindowID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetWindowID(WindowHandle window) => - Underlying.Value!.GetWindowID(window); + public static RendererHandle CreateRendererWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateRendererWithProperties(props); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowKeyboardGrab(WindowHandle window) => - Underlying.Value!.GetWindowKeyboardGrab(window); + public static RWLockHandle CreateRWLock() => Underlying.Value!.CreateRWLock(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowKeyboardGrabRaw(WindowHandle window) => - Underlying.Value!.GetWindowKeyboardGrabRaw(window); + public static SemaphoreHandle CreateSemaphore( + [NativeTypeName("Uint32")] uint initial_value + ) => Underlying.Value!.CreateSemaphore(initial_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => - Underlying.Value!.GetWindowMaximumSize(window, w, h); + public static RendererHandle CreateSoftwareRenderer(Surface* surface) => + Underlying.Value!.CreateSoftwareRenderer(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowMaximumSize( - WindowHandle window, - Ref w, - Ref h - ) + public static RendererHandle CreateSoftwareRenderer(Ref surface) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)GetWindowMaximumSize(window, __dsl_w, __dsl_h); + return (RendererHandle)CreateSoftwareRenderer(__dsl_surface); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => - Underlying.Value!.GetWindowMinimumSize(window, w, h); + public static byte CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => Underlying.Value!.CreateStorageDirectory(storage, path); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowMinimumSize( - WindowHandle window, - Ref w, - Ref h + public static MaybeBool CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (sbyte* __dsl_path = path) { - return (MaybeBool)(byte)GetWindowMinimumSize(window, __dsl_w, __dsl_h); + return (MaybeBool)(byte)CreateStorageDirectory(storage, __dsl_path); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowMouseGrab(WindowHandle window) => - Underlying.Value!.GetWindowMouseGrab(window); + public static Ptr CreateSurface(int width, int height, PixelFormat format) => + Underlying.Value!.CreateSurface(width, height, format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowMouseGrabRaw(WindowHandle window) => - Underlying.Value!.GetWindowMouseGrabRaw(window); + public static Surface* CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + void* pixels, + int pitch + ) => Underlying.Value!.CreateSurfaceFrom(width, height, format, pixels, pitch); - [return: NativeTypeName("const SDL_Rect *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindowMouseRect(WindowHandle window) => - Underlying.Value!.GetWindowMouseRect(window); + public static Ptr CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + Ref pixels, + int pitch + ) + { + fixed (void* __dsl_pixels = pixels) + { + return (Surface*)CreateSurfaceFrom(width, height, format, __dsl_pixels, pitch); + } + } - [return: NativeTypeName("const SDL_Rect *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Rect* GetWindowMouseRectRaw(WindowHandle window) => - Underlying.Value!.GetWindowMouseRectRaw(window); + public static Palette* CreateSurfacePalette(Surface* surface) => + Underlying.Value!.CreateSurfacePalette(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetWindowOpacity(WindowHandle window) => - Underlying.Value!.GetWindowOpacity(window); + public static Ptr CreateSurfacePalette(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Palette*)CreateSurfacePalette(__dsl_surface); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GetWindowParent(WindowHandle window) => - Underlying.Value!.GetWindowParent(window); + public static Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => + Underlying.Value!.CreateSurfaceRaw(width, height, format); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static float GetWindowPixelDensity(WindowHandle window) => - Underlying.Value!.GetWindowPixelDensity(window); + public static CursorHandle CreateSystemCursor(SystemCursor id) => + Underlying.Value!.CreateSystemCursor(id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static PixelFormat GetWindowPixelFormat(WindowHandle window) => - Underlying.Value!.GetWindowPixelFormat(window); + public static Ptr CreateTexture( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => Underlying.Value!.CreateTexture(renderer, format, access, w, h); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowPosition(WindowHandle window, int* x, int* y) => - Underlying.Value!.GetWindowPosition(window, x, y); + public static Texture* CreateTextureFromSurface( + RendererHandle renderer, + Surface* surface + ) => Underlying.Value!.CreateTextureFromSurface(renderer, surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) + public static Ptr CreateTextureFromSurface( + RendererHandle renderer, + Ref surface + ) { - fixed (int* __dsl_y = y) - fixed (int* __dsl_x = x) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)GetWindowPosition(window, __dsl_x, __dsl_y); + return (Texture*)CreateTextureFromSurface(renderer, __dsl_surface); } } - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint GetWindowProperties(WindowHandle window) => - Underlying.Value!.GetWindowProperties(window); + public static Texture* CreateTextureRaw( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => Underlying.Value!.CreateTextureRaw(renderer, format, access, w, h); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => - Underlying.Value!.GetWindowRelativeMouseMode(window); + public static Ptr CreateTextureWithProperties( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateTextureWithProperties(renderer, props); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowRelativeMouseModeRaw(WindowHandle window) => - Underlying.Value!.GetWindowRelativeMouseModeRaw(window); + public static Texture* CreateTextureWithPropertiesRaw( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateTextureWithPropertiesRaw(renderer, props); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle* GetWindows(int* count) => Underlying.Value!.GetWindows(count); + public static ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] sbyte* name, + void* data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => Underlying.Value!.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindows(Ref count) + public static ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] Ref name, + Ref data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) { - fixed (int* __dsl_count = count) + fixed (void* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { - return (WindowHandle*)GetWindows(__dsl_count); + return (ThreadHandle)CreateThreadRuntime( + fn, + __dsl_name, + __dsl_data, + pfnBeginThread, + pfnEndThread + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte GetWindowSafeArea(WindowHandle window, Rect* rect) => - Underlying.Value!.GetWindowSafeArea(window, rect); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)GetWindowSafeArea(window, __dsl_rect); - } - } + public static ThreadHandle CreateThreadWithPropertiesRuntime( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => + Underlying.Value!.CreateThreadWithPropertiesRuntime( + props, + pfnBeginThread, + pfnEndThread + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowSize(WindowHandle window, int* w, int* h) => - Underlying.Value!.GetWindowSize(window, w, h); + public static WindowHandle CreateWindow( + [NativeTypeName("const char *")] sbyte* title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => Underlying.Value!.CreateWindow(title, w, h, flags); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) + public static WindowHandle CreateWindow( + [NativeTypeName("const char *")] Ref title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (sbyte* __dsl_title = title) { - return (MaybeBool)(byte)GetWindowSize(window, __dsl_w, __dsl_h); + return (WindowHandle)CreateWindow(__dsl_title, w, h, flags); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => - Underlying.Value!.GetWindowSizeInPixels(window, w, h); + public static byte CreateWindowAndRenderer( + [NativeTypeName("const char *")] sbyte* title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + WindowHandle* window, + RendererHandle* renderer + ) => + Underlying.Value!.CreateWindowAndRenderer( + title, + width, + height, + window_flags, + window, + renderer + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowSizeInPixels( - WindowHandle window, - Ref w, - Ref h + public static MaybeBool CreateWindowAndRenderer( + [NativeTypeName("const char *")] Ref title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + Ref window, + Ref renderer ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (RendererHandle* __dsl_renderer = renderer) + fixed (WindowHandle* __dsl_window = window) + fixed (sbyte* __dsl_title = title) { - return (MaybeBool)(byte)GetWindowSizeInPixels(window, __dsl_w, __dsl_h); + return (MaybeBool) + (byte)CreateWindowAndRenderer( + __dsl_title, + width, + height, + window_flags, + __dsl_window, + __dsl_renderer + ); } } + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static WindowHandle CreateWindowWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.CreateWindowWithProperties(props); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindowSurface(WindowHandle window) => - Underlying.Value!.GetWindowSurface(window); + public static MaybeBool CursorVisible() => Underlying.Value!.CursorVisible(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* GetWindowSurfaceRaw(WindowHandle window) => - Underlying.Value!.GetWindowSurfaceRaw(window); + public static byte CursorVisibleRaw() => Underlying.Value!.CursorVisibleRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => - Underlying.Value!.GetWindowSurfaceVSync(window, vsync); + public static byte DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] DateTime* dt, + [NativeTypeName("SDL_Time *")] long* ticks + ) => Underlying.Value!.DateTimeToTime(dt, ticks); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) + public static MaybeBool DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] Ref dt, + [NativeTypeName("SDL_Time *")] Ref ticks + ) { - fixed (int* __dsl_vsync = vsync) + fixed (long* __dsl_ticks = ticks) + fixed (DateTime* __dsl_dt = dt) { - return (MaybeBool)(byte)GetWindowSurfaceVSync(window, __dsl_vsync); + return (MaybeBool)(byte)DateTimeToTime(__dsl_dt, __dsl_ticks); } } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr GetWindowTitle(WindowHandle window) => - Underlying.Value!.GetWindowTitle(window); + public static void Delay([NativeTypeName("Uint32")] uint ms) => Underlying.Value!.Delay(ms); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte* GetWindowTitleRaw(WindowHandle window) => - Underlying.Value!.GetWindowTitleRaw(window); + public static void DelayNS([NativeTypeName("Uint64")] ulong ns) => + Underlying.Value!.DelayNS(ns); - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GLContextStateHandle GLCreateContext(WindowHandle window) => - Underlying.Value!.GLCreateContext(window); + public static void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => + Underlying.Value!.DelayPrecise(ns); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLDestroyContext( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => Underlying.Value!.GLDestroyContext(context); + public static void DestroyAudioStream(AudioStreamHandle stream) => + Underlying.Value!.DestroyAudioStream(stream); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLDestroyContextRaw( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => Underlying.Value!.GLDestroyContextRaw(context); + public static void DestroyCondition(ConditionHandle cond) => + Underlying.Value!.DestroyCondition(cond); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLExtensionSupported( - [NativeTypeName("const char *")] sbyte* extension - ) => Underlying.Value!.GLExtensionSupported(extension); + public static void DestroyCursor(CursorHandle cursor) => + Underlying.Value!.DestroyCursor(cursor); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLExtensionSupported( - [NativeTypeName("const char *")] Ref extension - ) - { - fixed (sbyte* __dsl_extension = extension) - { - return (MaybeBool)(byte)GLExtensionSupported(__dsl_extension); - } - } + public static void DestroyEnvironment(EnvironmentHandle env) => + Underlying.Value!.DestroyEnvironment(env); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyGPUDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLGetAttribute(GLAttr attr, int* value) => - Underlying.Value!.GLGetAttribute(attr, value); + public static void DestroyGPUDevice(GPUDeviceHandle device) => + Underlying.Value!.DestroyGPUDevice(device); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DestroyHapticEffect(HapticHandle haptic, int effect) => + Underlying.Value!.DestroyHapticEffect(haptic, effect); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DestroyMutex(MutexHandle mutex) => Underlying.Value!.DestroyMutex(mutex); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DestroyPalette(Palette* palette) => + Underlying.Value!.DestroyPalette(palette); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLGetAttribute(GLAttr attr, Ref value) + public static void DestroyPalette(Ref palette) { - fixed (int* __dsl_value = value) + fixed (Palette* __dsl_palette = palette) { - return (MaybeBool)(byte)GLGetAttribute(attr, __dsl_value); + DestroyPalette(__dsl_palette); } } - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProcess")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GLContextStateHandle GLGetCurrentContext() => - Underlying.Value!.GLGetCurrentContext(); + public static void DestroyProcess(ProcessHandle process) => + Underlying.Value!.DestroyProcess(process); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static WindowHandle GLGetCurrentWindow() => Underlying.Value!.GLGetCurrentWindow(); + public static void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + Underlying.Value!.DestroyProperties(props); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer GLGetProcAddress( - [NativeTypeName("const char *")] sbyte* proc - ) => Underlying.Value!.GLGetProcAddress(proc); + public static void DestroyRenderer(RendererHandle renderer) => + Underlying.Value!.DestroyRenderer(renderer); - [return: NativeTypeName("SDL_FunctionPointer")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer GLGetProcAddress( - [NativeTypeName("const char *")] Ref proc - ) - { - fixed (sbyte* __dsl_proc = proc) - { - return (FunctionPointer)GLGetProcAddress(__dsl_proc); - } - } + public static void DestroyRWLock(RWLockHandle rwlock) => + Underlying.Value!.DestroyRWLock(rwlock); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLGetSwapInterval(int* interval) => - Underlying.Value!.GLGetSwapInterval(interval); + public static void DestroySemaphore(SemaphoreHandle sem) => + Underlying.Value!.DestroySemaphore(sem); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void DestroySurface(Surface* surface) => + Underlying.Value!.DestroySurface(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLGetSwapInterval(Ref interval) + public static void DestroySurface(Ref surface) { - fixed (int* __dsl_interval = interval) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)GLGetSwapInterval(__dsl_interval); + DestroySurface(__dsl_surface); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => - Underlying.Value!.GLLoadLibrary(path); + public static void DestroyTexture(Texture* texture) => + Underlying.Value!.DestroyTexture(texture); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLLoadLibrary( - [NativeTypeName("const char *")] Ref path - ) + public static void DestroyTexture(Ref texture) { - fixed (sbyte* __dsl_path = path) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)GLLoadLibrary(__dsl_path); + DestroyTexture(__dsl_texture); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLMakeCurrent( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => Underlying.Value!.GLMakeCurrent(window, context); + public static void DestroyWindow(WindowHandle window) => + Underlying.Value!.DestroyWindow(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLMakeCurrentRaw( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => Underlying.Value!.GLMakeCurrentRaw(window, context); + public static MaybeBool DestroyWindowSurface(WindowHandle window) => + Underlying.Value!.DestroyWindowSurface(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GLResetAttributes() => Underlying.Value!.GLResetAttributes(); + public static byte DestroyWindowSurfaceRaw(WindowHandle window) => + Underlying.Value!.DestroyWindowSurfaceRaw(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLSetAttribute(GLAttr attr, int value) => - Underlying.Value!.GLSetAttribute(attr, value); + public static void DetachThread(ThreadHandle thread) => + Underlying.Value!.DetachThread(thread); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLSetAttributeRaw(GLAttr attr, int value) => - Underlying.Value!.GLSetAttributeRaw(attr, value); + public static MaybeBool DetachVirtualJoystick( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.DetachVirtualJoystick(instance_id); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLSetSwapInterval(int interval) => - Underlying.Value!.GLSetSwapInterval(interval); + public static byte DetachVirtualJoystickRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.DetachVirtualJoystickRaw(instance_id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLSetSwapIntervalRaw(int interval) => - Underlying.Value!.GLSetSwapIntervalRaw(interval); + public static MaybeBool DisableScreenSaver() => + Underlying.Value!.DisableScreenSaver(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool GLSwapWindow(WindowHandle window) => - Underlying.Value!.GLSwapWindow(window); + public static byte DisableScreenSaverRaw() => Underlying.Value!.DisableScreenSaverRaw(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUCompute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte GLSwapWindowRaw(WindowHandle window) => - Underlying.Value!.GLSwapWindowRaw(window); + public static void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ) => + Underlying.Value!.DispatchGPUCompute( + compute_pass, + groupcount_x, + groupcount_y, + groupcount_z + ); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUComputeIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GLUnloadLibrary() => Underlying.Value!.GLUnloadLibrary(); + public static void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ) => Underlying.Value!.DispatchGPUComputeIndirect(compute_pass, buffer, offset); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte** GlobDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => Underlying.Value!.GlobDirectory(path, pattern, flags, count); + public static void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ) => Underlying.Value!.DownloadFromGPUBuffer(copy_pass, source, destination); - [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GlobDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count + public static void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination ) { - fixed (int* __dsl_count = count) - fixed (sbyte* __dsl_pattern = pattern) - fixed (sbyte* __dsl_path = path) + fixed (GPUTransferBufferLocation* __dsl_destination = destination) + fixed (GPUBufferRegion* __dsl_source = source) { - return (sbyte**)GlobDirectory(__dsl_path, __dsl_pattern, flags, __dsl_count); + DownloadFromGPUBuffer(copy_pass, __dsl_source, __dsl_destination); } } - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static sbyte** GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => Underlying.Value!.GlobStorageDirectory(storage, path, pattern, flags, count); + public static void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + GPUTextureTransferInfo* destination + ) => Underlying.Value!.DownloadFromGPUTexture(copy_pass, source, destination); - [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr2D GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count + public static void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination ) { - fixed (int* __dsl_count = count) - fixed (sbyte* __dsl_pattern = pattern) - fixed (sbyte* __dsl_path = path) + fixed (GPUTextureTransferInfo* __dsl_destination = destination) + fixed (GPUTextureRegion* __dsl_source = source) { - return (sbyte**)GlobStorageDirectory( - storage, - __dsl_path, - __dsl_pattern, - flags, - __dsl_count - ); + DownloadFromGPUTexture(copy_pass, __dsl_source, __dsl_destination); } } - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitives")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GuidToString( - Guid guid, - [NativeTypeName("char *")] sbyte* pszGUID, - int cbGUID - ) => Underlying.Value!.GuidToString(guid, pszGUID, cbGUID); + public static void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ) => + Underlying.Value!.DrawGPUIndexedPrimitives( + render_pass, + num_indices, + num_instances, + first_index, + vertex_offset, + first_instance + ); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void GuidToString( - Guid guid, - [NativeTypeName("char *")] Ref pszGUID, - int cbGUID - ) - { - fixed (sbyte* __dsl_pszGUID = pszGUID) - { - GuidToString(guid, __dsl_pszGUID, cbGUID); - } - } + public static void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => + Underlying.Value!.DrawGPUIndexedPrimitivesIndirect( + render_pass, + buffer, + offset, + draw_count + ); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitives")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => Underlying.Value!.HapticEffectSupported(haptic, effect); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) - { - fixed (HapticEffect* __dsl_effect = effect) - { - return (MaybeBool)(byte)HapticEffectSupported(haptic, __dsl_effect); - } - } + public static void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ) => + Underlying.Value!.DrawGPUPrimitives( + render_pass, + num_vertices, + num_instances, + first_vertex, + first_instance + ); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HapticRumbleSupported(HapticHandle haptic) => - Underlying.Value!.HapticRumbleSupported(haptic); + public static void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => Underlying.Value!.DrawGPUPrimitivesIndirect(render_pass, buffer, offset, draw_count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HapticRumbleSupportedRaw(HapticHandle haptic) => - Underlying.Value!.HapticRumbleSupportedRaw(haptic); + public static Surface* DuplicateSurface(Surface* surface) => + Underlying.Value!.DuplicateSurface(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool HasAltiVec() => Underlying.Value!.HasAltiVec(); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasAltiVecRaw() => Underlying.Value!.HasAltiVecRaw(); + public static Ptr DuplicateSurface(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Surface*)DuplicateSurface(__dsl_surface); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_EGLConfig")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasArmsimd() => Underlying.Value!.HasArmsimd(); + public static Ptr EGLGetCurrentConfig() => Underlying.Value!.EGLGetCurrentConfig(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [return: NativeTypeName("SDL_EGLConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasArmsimdRaw() => Underlying.Value!.HasArmsimdRaw(); + public static void* EGLGetCurrentConfigRaw() => Underlying.Value!.EGLGetCurrentConfigRaw(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_EGLDisplay")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasAVX() => Underlying.Value!.HasAVX(); + public static Ptr EGLGetCurrentDisplay() => Underlying.Value!.EGLGetCurrentDisplay(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [return: NativeTypeName("SDL_EGLDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasAVX2() => Underlying.Value!.HasAVX2(); + public static void* EGLGetCurrentDisplayRaw() => + Underlying.Value!.EGLGetCurrentDisplayRaw(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasAVX2Raw() => Underlying.Value!.HasAVX2Raw(); + public static FunctionPointer EGLGetProcAddress( + [NativeTypeName("const char *")] sbyte* proc + ) => Underlying.Value!.EGLGetProcAddress(proc); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasAVX512F() => Underlying.Value!.HasAVX512F(); + public static FunctionPointer EGLGetProcAddress( + [NativeTypeName("const char *")] Ref proc + ) + { + fixed (sbyte* __dsl_proc = proc) + { + return (FunctionPointer)EGLGetProcAddress(__dsl_proc); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [return: NativeTypeName("SDL_EGLSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasAVX512FRaw() => Underlying.Value!.HasAVX512FRaw(); + public static Ptr EGLGetWindowSurface(WindowHandle window) => + Underlying.Value!.EGLGetWindowSurface(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [return: NativeTypeName("SDL_EGLSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasAVXRaw() => Underlying.Value!.HasAVXRaw(); + public static void* EGLGetWindowSurfaceRaw(WindowHandle window) => + Underlying.Value!.EGLGetWindowSurfaceRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => - Underlying.Value!.HasClipboardData(mime_type); + public static void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, + void* userdata + ) => + Underlying.Value!.EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + userdata + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasClipboardData( - [NativeTypeName("const char *")] Ref mime_type + public static void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, + Ref userdata ) { - fixed (sbyte* __dsl_mime_type = mime_type) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool)(byte)HasClipboardData(__dsl_mime_type); + EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + __dsl_userdata + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasClipboardText() => Underlying.Value!.HasClipboardText(); + public static MaybeBool EnableScreenSaver() => Underlying.Value!.EnableScreenSaver(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasClipboardTextRaw() => Underlying.Value!.HasClipboardTextRaw(); + public static byte EnableScreenSaverRaw() => Underlying.Value!.EnableScreenSaverRaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUComputePass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => - Underlying.Value!.HasEvent(type); + public static void EndGPUComputePass(GPUComputePassHandle compute_pass) => + Underlying.Value!.EndGPUComputePass(compute_pass); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUCopyPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasEventRaw([NativeTypeName("Uint32")] uint type) => - Underlying.Value!.HasEventRaw(type); + public static void EndGPUCopyPass(GPUCopyPassHandle copy_pass) => + Underlying.Value!.EndGPUCopyPass(copy_pass); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPURenderPass")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => Underlying.Value!.HasEvents(minType, maxType); + public static void EndGPURenderPass(GPURenderPassHandle render_pass) => + Underlying.Value!.EndGPURenderPass(render_pass); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasEventsRaw( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => Underlying.Value!.HasEventsRaw(minType, maxType); + public static int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => + Underlying.Value!.EnterAppMainCallbacks( + argc, + argv, + appinit, + appiter, + appevent, + appquit + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasGamepad() => Underlying.Value!.HasGamepad(); + public static int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) + { + fixed (sbyte** __dsl_argv = argv) + { + return (int)EnterAppMainCallbacks( + argc, + __dsl_argv, + appinit, + appiter, + appevent, + appquit + ); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasGamepadRaw() => Underlying.Value!.HasGamepadRaw(); + public static byte EnumerateDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata + ) => Underlying.Value!.EnumerateDirectory(path, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasJoystick() => Underlying.Value!.HasJoystick(); + public static MaybeBool EnumerateDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)EnumerateDirectory(__dsl_path, callback, __dsl_userdata); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasJoystickRaw() => Underlying.Value!.HasJoystickRaw(); + public static byte EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] + EnumeratePropertiesCallback callback, + void* userdata + ) => Underlying.Value!.EnumerateProperties(props, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasKeyboard() => Underlying.Value!.HasKeyboard(); + public static MaybeBool EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] + EnumeratePropertiesCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool)(byte)EnumerateProperties(props, callback, __dsl_userdata); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasKeyboardRaw() => Underlying.Value!.HasKeyboardRaw(); + public static byte EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata + ) => Underlying.Value!.EnumerateStorageDirectory(storage, path, callback, userdata); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool HasLasx() => Underlying.Value!.HasLasx(); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasLasxRaw() => Underlying.Value!.HasLasxRaw(); + public static MaybeBool EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)EnumerateStorageDirectory(storage, __dsl_path, callback, __dsl_userdata); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasLSX() => Underlying.Value!.HasLSX(); + public static MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => + Underlying.Value!.EventEnabled(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasLSXRaw() => Underlying.Value!.HasLSXRaw(); + public static byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => + Underlying.Value!.EventEnabledRaw(type); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_exp")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasMMX() => Underlying.Value!.HasMMX(); + public static double Exp(double x) => Underlying.Value!.Exp(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_expf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasMMXRaw() => Underlying.Value!.HasMMXRaw(); + public static float Expf(float x) => Underlying.Value!.Expf(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_fabs")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasMouse() => Underlying.Value!.HasMouse(); + public static double Fabs(double x) => Underlying.Value!.Fabs(x); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasMouseRaw() => Underlying.Value!.HasMouseRaw(); + public static byte FillSurfaceRect( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("Uint32")] uint color + ) => Underlying.Value!.FillSurfaceRect(dst, rect, color); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasNeon() => Underlying.Value!.HasNeon(); + public static MaybeBool FillSurfaceRect( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("Uint32")] uint color + ) + { + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_dst = dst) + { + return (MaybeBool)(byte)FillSurfaceRect(__dsl_dst, __dsl_rect, color); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasNeonRaw() => Underlying.Value!.HasNeonRaw(); + public static byte FillSurfaceRects( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int count, + [NativeTypeName("Uint32")] uint color + ) => Underlying.Value!.FillSurfaceRects(dst, rects, count, color); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool HasPrimarySelectionText() => - Underlying.Value!.HasPrimarySelectionText(); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasPrimarySelectionTextRaw() => - Underlying.Value!.HasPrimarySelectionTextRaw(); + public static MaybeBool FillSurfaceRects( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rects, + int count, + [NativeTypeName("Uint32")] uint color + ) + { + fixed (Rect* __dsl_rects = rects) + fixed (Surface* __dsl_dst = dst) + { + return (MaybeBool) + (byte)FillSurfaceRects(__dsl_dst, __dsl_rects, count, color); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.HasProperty(props, name); + public static void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => Underlying.Value!.FilterEvents(filter, userdata); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name + public static void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata ) { - fixed (sbyte* __dsl_name = name) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool)(byte)HasProperty(props, __dsl_name); + FilterEvents(filter, __dsl_userdata); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B - ) => Underlying.Value!.HasRectIntersection(A, B); + public static MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => + Underlying.Value!.FlashWindow(window, operation); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B - ) - { - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) - { - return (MaybeBool)(byte)HasRectIntersection(__dsl_A, __dsl_B); - } - } + public static byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => + Underlying.Value!.FlashWindowRaw(window, operation); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B - ) => Underlying.Value!.HasRectIntersectionFloat(A, B); + public static byte FlipSurface(Surface* surface, FlipMode flip) => + Underlying.Value!.FlipSurface(surface, flip); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B - ) + public static MaybeBool FlipSurface(Ref surface, FlipMode flip) { - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)HasRectIntersectionFloat(__dsl_A, __dsl_B); + return (MaybeBool)(byte)FlipSurface(__dsl_surface, flip); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_floor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasScreenKeyboardSupport() => - Underlying.Value!.HasScreenKeyboardSupport(); + public static double Floor(double x) => Underlying.Value!.Floor(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_floorf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasScreenKeyboardSupportRaw() => - Underlying.Value!.HasScreenKeyboardSupportRaw(); + public static float Floorf(float x) => Underlying.Value!.Floorf(x); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasSSE() => Underlying.Value!.HasSSE(); + public static MaybeBool FlushAudioStream(AudioStreamHandle stream) => + Underlying.Value!.FlushAudioStream(stream); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasSSE2() => Underlying.Value!.HasSSE2(); + public static byte FlushAudioStreamRaw(AudioStreamHandle stream) => + Underlying.Value!.FlushAudioStreamRaw(stream); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasSSE2Raw() => Underlying.Value!.HasSSE2Raw(); + public static void FlushEvent([NativeTypeName("Uint32")] uint type) => + Underlying.Value!.FlushEvent(type); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasSSE3() => Underlying.Value!.HasSSE3(); + public static void FlushEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => Underlying.Value!.FlushEvents(minType, maxType); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasSSE3Raw() => Underlying.Value!.HasSSE3Raw(); + public static MaybeBool FlushIO(IOStreamHandle context) => + Underlying.Value!.FlushIO(context); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasSSE41() => Underlying.Value!.HasSSE41(); + public static byte FlushIORaw(IOStreamHandle context) => + Underlying.Value!.FlushIORaw(context); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasSSE41Raw() => Underlying.Value!.HasSSE41Raw(); + public static MaybeBool FlushRenderer(RendererHandle renderer) => + Underlying.Value!.FlushRenderer(renderer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HasSSE42() => Underlying.Value!.HasSSE42(); + public static byte FlushRendererRaw(RendererHandle renderer) => + Underlying.Value!.FlushRendererRaw(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [NativeFunction("SDL3", EntryPoint = "SDL_fmod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasSSE42Raw() => Underlying.Value!.HasSSE42Raw(); + public static double Fmod(double x, double y) => Underlying.Value!.Fmod(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [NativeFunction("SDL3", EntryPoint = "SDL_fmodf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HasSSERaw() => Underlying.Value!.HasSSERaw(); + public static float Fmodf(float x, float y) => Underlying.Value!.Fmodf(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void HidBleScan([NativeTypeName("bool")] byte active) => - Underlying.Value!.HidBleScan(active); + public static void Free(void* mem) => Underlying.Value!.Free(mem); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void HidBleScan([NativeTypeName("bool")] MaybeBool active) => - Underlying.Value!.HidBleScan(active); + public static void Free(Ref mem) + { + fixed (void* __dsl_mem = mem) + { + Free(__dsl_mem); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidClose(HidDeviceHandle dev) => Underlying.Value!.HidClose(dev); + public static MaybeBool GamepadConnected(GamepadHandle gamepad) => + Underlying.Value!.GamepadConnected(gamepad); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint HidDeviceChangeCount() => Underlying.Value!.HidDeviceChangeCount(); - + public static byte GamepadConnectedRaw(GamepadHandle gamepad) => + Underlying.Value!.GamepadConnectedRaw(gamepad); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr HidEnumerate( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => Underlying.Value!.HidEnumerate(vendor_id, product_id); + public static MaybeBool GamepadEventsEnabled() => + Underlying.Value!.GamepadEventsEnabled(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceInfo* HidEnumerateRaw( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => Underlying.Value!.HidEnumerateRaw(vendor_id, product_id); + public static byte GamepadEventsEnabledRaw() => Underlying.Value!.GamepadEventsEnabledRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidExit() => Underlying.Value!.HidExit(); + public static MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => + Underlying.Value!.GamepadHasAxis(gamepad, axis); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void HidFreeEnumeration(HidDeviceInfo* devs) => - Underlying.Value!.HidFreeEnumeration(devs); + public static byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => + Underlying.Value!.GamepadHasAxisRaw(gamepad, axis); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void HidFreeEnumeration(Ref devs) - { - fixed (HidDeviceInfo* __dsl_devs = devs) - { - HidFreeEnumeration(__dsl_devs); - } - } + public static MaybeBool GamepadHasButton( + GamepadHandle gamepad, + GamepadButton button + ) => Underlying.Value!.GamepadHasButton(gamepad, button); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => + Underlying.Value!.GamepadHasButtonRaw(gamepad, button); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr HidGetDeviceInfo(HidDeviceHandle dev) => - Underlying.Value!.HidGetDeviceInfo(dev); + public static MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => + Underlying.Value!.GamepadHasSensor(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => - Underlying.Value!.HidGetDeviceInfoRaw(dev); + public static byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => + Underlying.Value!.GamepadHasSensorRaw(gamepad, type); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => Underlying.Value!.HidGetFeatureReport(dev, data, length); + public static MaybeBool GamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type + ) => Underlying.Value!.GamepadSensorEnabled(gamepad, type); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => + Underlying.Value!.GamepadSensorEnabledRaw(gamepad, type); + + [NativeFunction("SDL3", EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ) => Underlying.Value!.GenerateMipmapsForGPUTexture(command_buffer, texture); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.GetAppMetadataProperty(name); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length + public static Ptr GetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name ) { - fixed (byte* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { - return (int)HidGetFeatureReport(dev, __dsl_data, length); + return (sbyte*)GetAppMetadataProperty(__dsl_name); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => Underlying.Value!.HidGetIndexedString(dev, string_index, @string, maxlen); + public static AssertionHandler GetAssertionHandler(void** puserdata) => + Underlying.Value!.GetAssertionHandler(puserdata); + [return: NativeTypeName("SDL_AssertionHandler")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + public static AssertionHandler GetAssertionHandler(Ref2D puserdata) { - fixed (uint* __dsl_string = @string) + fixed (void** __dsl_puserdata = puserdata) { - return (int)HidGetIndexedString(dev, string_index, __dsl_string, maxlen); + return (AssertionHandler)GetAssertionHandler(__dsl_puserdata); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [return: NativeTypeName("const SDL_AssertData *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => Underlying.Value!.HidGetInputReport(dev, data, length); + public static Ptr GetAssertionReport() => + Underlying.Value!.GetAssertionReport(); + + [return: NativeTypeName("const SDL_AssertData *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static AssertData* GetAssertionReportRaw() => + Underlying.Value!.GetAssertionReportRaw(); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int GetAtomicInt(AtomicInt* a) => Underlying.Value!.GetAtomicInt(a); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) + public static int GetAtomicInt(Ref a) { - fixed (byte* __dsl_data = data) + fixed (AtomicInt* __dsl_a = a) { - return (int)HidGetInputReport(dev, __dsl_data, length); + return (int)GetAtomicInt(__dsl_a); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => Underlying.Value!.HidGetManufacturerString(dev, @string, maxlen); + public static void* GetAtomicPointer(void** a) => Underlying.Value!.GetAtomicPointer(a); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + public static Ptr GetAtomicPointer(Ref2D a) { - fixed (uint* __dsl_string = @string) + fixed (void** __dsl_a = a) { - return (int)HidGetManufacturerString(dev, __dsl_string, maxlen); + return (void*)GetAtomicPointer(__dsl_a); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => Underlying.Value!.HidGetProductString(dev, @string, maxlen); + public static uint GetAtomicU32(AtomicU32* a) => Underlying.Value!.GetAtomicU32(a); + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + public static uint GetAtomicU32(Ref a) { - fixed (uint* __dsl_string = @string) + fixed (AtomicU32* __dsl_a = a) { - return (int)HidGetProductString(dev, __dsl_string, maxlen); + return (uint)GetAtomicU32(__dsl_a); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* buf, - [NativeTypeName("size_t")] nuint buf_size - ) => Underlying.Value!.HidGetReportDescriptor(dev, buf, buf_size); + public static int* GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + int* count + ) => Underlying.Value!.GetAudioDeviceChannelMap(devid, count); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref buf, - [NativeTypeName("size_t")] nuint buf_size + public static Ptr GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref count ) { - fixed (byte* __dsl_buf = buf) + fixed (int* __dsl_count = count) { - return (int)HidGetReportDescriptor(dev, __dsl_buf, buf_size); + return (int*)GetAudioDeviceChannelMap(devid, __dsl_count); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => Underlying.Value!.HidGetSerialNumberString(dev, @string, maxlen); + public static byte GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioSpec* spec, + int* sample_frames + ) => Underlying.Value!.GetAudioDeviceFormat(devid, spec, sample_frames); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen + public static MaybeBool GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref spec, + Ref sample_frames ) { - fixed (uint* __dsl_string = @string) + fixed (int* __dsl_sample_frames = sample_frames) + fixed (AudioSpec* __dsl_spec = spec) { - return (int)HidGetSerialNumberString(dev, __dsl_string, maxlen); + return (MaybeBool) + (byte)GetAudioDeviceFormat(devid, __dsl_spec, __dsl_sample_frames); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidInit() => Underlying.Value!.HidInit(); + public static float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + Underlying.Value!.GetAudioDeviceGain(devid); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] uint* serial_number - ) => Underlying.Value!.HidOpen(vendor_id, product_id, serial_number); + public static Ptr GetAudioDeviceName( + [NativeTypeName("SDL_AudioDeviceID")] uint devid + ) => Underlying.Value!.GetAudioDeviceName(devid); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] Ref serial_number - ) - { - fixed (uint* __dsl_serial_number = serial_number) - { - return (HidDeviceHandle)HidOpen(vendor_id, product_id, __dsl_serial_number); - } - } + public static sbyte* GetAudioDeviceNameRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid + ) => Underlying.Value!.GetAudioDeviceNameRaw(devid); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => - Underlying.Value!.HidOpenPath(path); + public static Ptr GetAudioDriver(int index) => + Underlying.Value!.GetAudioDriver(index); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) - { - fixed (sbyte* __dsl_path = path) - { - return (HidDeviceHandle)HidOpenPath(__dsl_path); - } - } + public static sbyte* GetAudioDriverRaw(int index) => + Underlying.Value!.GetAudioDriverRaw(index); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => Underlying.Value!.HidRead(dev, data, length); + public static Ptr GetAudioFormatName(AudioFormat format) => + Underlying.Value!.GetAudioFormatName(format); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) - { - fixed (byte* __dsl_data = data) - { - return (int)HidRead(dev, __dsl_data, length); - } - } + public static sbyte* GetAudioFormatNameRaw(AudioFormat format) => + Underlying.Value!.GetAudioFormatNameRaw(format); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) => Underlying.Value!.HidReadTimeout(dev, data, length, milliseconds); + public static uint* GetAudioPlaybackDevices(int* count) => + Underlying.Value!.GetAudioPlaybackDevices(count); + [return: NativeTypeName("SDL_AudioDeviceID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) + public static Ptr GetAudioPlaybackDevices(Ref count) { - fixed (byte* __dsl_data = data) + fixed (int* __dsl_count = count) { - return (int)HidReadTimeout(dev, __dsl_data, length, milliseconds); + return (uint*)GetAudioPlaybackDevices(__dsl_count); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => Underlying.Value!.HidSendFeatureReport(dev, data, length); + public static uint* GetAudioRecordingDevices(int* count) => + Underlying.Value!.GetAudioRecordingDevices(count); + [return: NativeTypeName("SDL_AudioDeviceID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) + public static Ptr GetAudioRecordingDevices(Ref count) { - fixed (byte* __dsl_data = data) + fixed (int* __dsl_count = count) { - return (int)HidSendFeatureReport(dev, __dsl_data, length); + return (uint*)GetAudioRecordingDevices(__dsl_count); } } - [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => - Underlying.Value!.HidSetNonblocking(dev, nonblock); + public static int GetAudioStreamAvailable(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamAvailable(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => Underlying.Value!.HidWrite(dev, data, length); + public static int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => + Underlying.Value!.GetAudioStreamData(stream, buf, len); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) + public static int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) { - fixed (byte* __dsl_data = data) + fixed (void* __dsl_buf = buf) { - return (int)HidWrite(dev, __dsl_data, length); + return (int)GetAudioStreamData(stream, __dsl_buf, len); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HideCursor() => Underlying.Value!.HideCursor(); + public static uint GetAudioStreamDevice(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamDevice(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HideCursorRaw() => Underlying.Value!.HideCursorRaw(); + public static byte GetAudioStreamFormat( + AudioStreamHandle stream, + AudioSpec* src_spec, + AudioSpec* dst_spec + ) => Underlying.Value!.GetAudioStreamFormat(stream, src_spec, dst_spec); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool HideWindow(WindowHandle window) => - Underlying.Value!.HideWindow(window); + public static MaybeBool GetAudioStreamFormat( + AudioStreamHandle stream, + Ref src_spec, + Ref dst_spec + ) + { + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) + { + return (MaybeBool) + (byte)GetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte HideWindowRaw(WindowHandle window) => - Underlying.Value!.HideWindowRaw(window); + public static float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamFrequencyRatio(stream); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.Init(flags); + public static float GetAudioStreamGain(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamGain(stream); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool InitHapticRumble(HapticHandle haptic) => - Underlying.Value!.InitHapticRumble(haptic); + public static int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => + Underlying.Value!.GetAudioStreamInputChannelMap(stream, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte InitHapticRumbleRaw(HapticHandle haptic) => - Underlying.Value!.InitHapticRumbleRaw(haptic); + public static Ptr GetAudioStreamInputChannelMap( + AudioStreamHandle stream, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (int*)GetAudioStreamInputChannelMap(stream, __dsl_count); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.InitRaw(flags); + public static int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => + Underlying.Value!.GetAudioStreamOutputChannelMap(stream, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.InitSubSystem(flags); + public static Ptr GetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (int*)GetAudioStreamOutputChannelMap(stream, __dsl_count); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.InitSubSystemRaw(flags); + public static uint GetAudioStreamProperties(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamProperties(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] void* mem, - [NativeTypeName("size_t")] nuint size - ) => Underlying.Value!.IOFromConstMem(mem, size); + public static int GetAudioStreamQueued(AudioStreamHandle stream) => + Underlying.Value!.GetAudioStreamQueued(stream); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] Ref mem, - [NativeTypeName("size_t")] nuint size - ) - { - fixed (void* __dsl_mem = mem) - { - return (IOStreamHandle)IOFromConstMem(__dsl_mem, size); - } - } + public static Ptr GetBasePath() => Underlying.Value!.GetBasePath(); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromDynamicMem() => Underlying.Value!.IOFromDynamicMem(); + public static sbyte* GetBasePathRaw() => Underlying.Value!.GetBasePathRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("const char *")] sbyte* mode - ) => Underlying.Value!.IOFromFile(file, mode); + public static byte GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value + ) => Underlying.Value!.GetBooleanProperty(props, name, default_value); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("const char *")] Ref mode + public static MaybeBool GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value ) { - fixed (sbyte* __dsl_mode = mode) - fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_name = name) { - return (IOStreamHandle)IOFromFile(__dsl_file, __dsl_mode); + return (MaybeBool) + (byte)GetBooleanProperty(props, __dsl_name, (byte)default_value); } } - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => - Underlying.Value!.IOFromMem(mem, size); + public static Ptr GetCameraDriver(int index) => + Underlying.Value!.GetCameraDriver(index); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) - { - fixed (void* __dsl_mem = mem) - { - return (IOStreamHandle)IOFromMem(__dsl_mem, size); - } - } + public static sbyte* GetCameraDriverRaw(int index) => + Underlying.Value!.GetCameraDriverRaw(index); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => Underlying.Value!.IOvprintf(context, fmt, ap); + public static byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => + Underlying.Value!.GetCameraFormat(camera, spec); - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) + public static MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) + fixed (CameraSpec* __dsl_spec = spec) { - return (nuint)IOvprintf(context, __dsl_fmt, __dsl_ap); + return (MaybeBool)(byte)GetCameraFormat(camera, __dsl_spec); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_CameraID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetCameraID(CameraHandle camera) => + Underlying.Value!.GetCameraID(camera); + + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsGamepad( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.IsGamepad(instance_id); + public static Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => + Underlying.Value!.GetCameraName(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - Underlying.Value!.IsGamepadRaw(instance_id); + public static sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => + Underlying.Value!.GetCameraNameRaw(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsJoystickHaptic(JoystickHandle joystick) => - Underlying.Value!.IsJoystickHaptic(joystick); + public static int GetCameraPermissionState(CameraHandle camera) => + Underlying.Value!.GetCameraPermissionState(camera); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsJoystickHapticRaw(JoystickHandle joystick) => - Underlying.Value!.IsJoystickHapticRaw(joystick); + public static CameraPosition GetCameraPosition( + [NativeTypeName("SDL_CameraID")] uint instance_id + ) => Underlying.Value!.GetCameraPosition(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsJoystickVirtual( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.IsJoystickVirtual(instance_id); + public static uint GetCameraProperties(CameraHandle camera) => + Underlying.Value!.GetCameraProperties(camera); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [return: NativeTypeName("SDL_CameraID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsJoystickVirtualRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.IsJoystickVirtualRaw(instance_id); + public static uint* GetCameras(int* count) => Underlying.Value!.GetCameras(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_CameraID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsMouseHaptic() => Underlying.Value!.IsMouseHaptic(); + public static Ptr GetCameras(Ref count) + { + fixed (int* __dsl_count = count) + { + return (uint*)GetCameras(__dsl_count); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsMouseHapticRaw() => Underlying.Value!.IsMouseHapticRaw(); + public static CameraSpec** GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + int* count + ) => Underlying.Value!.GetCameraSupportedFormats(devid, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsTablet() => Underlying.Value!.IsTablet(); + public static Ptr2D GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (CameraSpec**)GetCameraSupportedFormats(devid, __dsl_count); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsTabletRaw() => Underlying.Value!.IsTabletRaw(); + public static void* GetClipboardData( + [NativeTypeName("const char *")] sbyte* mime_type, + [NativeTypeName("size_t *")] nuint* size + ) => Underlying.Value!.GetClipboardData(mime_type, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool IsTV() => Underlying.Value!.IsTV(); + public static Ptr GetClipboardData( + [NativeTypeName("const char *")] Ref mime_type, + [NativeTypeName("size_t *")] Ref size + ) + { + fixed (nuint* __dsl_size = size) + fixed (sbyte* __dsl_mime_type = mime_type) + { + return (void*)GetClipboardData(__dsl_mime_type, __dsl_size); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte IsTVRaw() => Underlying.Value!.IsTVRaw(); + public static sbyte** GetClipboardMimeTypes( + [NativeTypeName("size_t *")] nuint* num_mime_types + ) => Underlying.Value!.GetClipboardMimeTypes(num_mime_types); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool JoystickConnected(JoystickHandle joystick) => - Underlying.Value!.JoystickConnected(joystick); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte JoystickConnectedRaw(JoystickHandle joystick) => - Underlying.Value!.JoystickConnectedRaw(joystick); + public static Ptr2D GetClipboardMimeTypes( + [NativeTypeName("size_t *")] Ref num_mime_types + ) + { + fixed (nuint* __dsl_num_mime_types = num_mime_types) + { + return (sbyte**)GetClipboardMimeTypes(__dsl_num_mime_types); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool JoystickEventsEnabled() => - Underlying.Value!.JoystickEventsEnabled(); + public static Ptr GetClipboardText() => Underlying.Value!.GetClipboardText(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte JoystickEventsEnabledRaw() => - Underlying.Value!.JoystickEventsEnabledRaw(); + public static sbyte* GetClipboardTextRaw() => Underlying.Value!.GetClipboardTextRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => - Underlying.Value!.LoadBMP(file); + public static byte GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] byte include_high_density_modes, + DisplayMode* mode + ) => + Underlying.Value!.GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + include_high_density_modes, + mode + ); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr LoadBMP([NativeTypeName("const char *")] Ref file) + public static MaybeBool GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] MaybeBool include_high_density_modes, + Ref mode + ) { - fixed (sbyte* __dsl_file = file) + fixed (DisplayMode* __dsl_mode = mode) { - return (Surface*)LoadBMP(__dsl_file); + return (MaybeBool) + (byte)GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + (byte)include_high_density_modes, + __dsl_mode + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* LoadBMPIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio - ) => Underlying.Value!.LoadBMPIO(src, closeio); + public static int GetCPUCacheLineSize() => Underlying.Value!.GetCPUCacheLineSize(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr LoadBMPIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => Underlying.Value!.LoadBMPIO(src, closeio); + public static Ptr GetCurrentAudioDriver() => + Underlying.Value!.GetCurrentAudioDriver(); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* LoadFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("size_t *")] nuint* datasize - ) => Underlying.Value!.LoadFile(file, datasize); + public static sbyte* GetCurrentAudioDriverRaw() => + Underlying.Value!.GetCurrentAudioDriverRaw(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr LoadFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("size_t *")] Ref datasize - ) - { - fixed (nuint* __dsl_datasize = datasize) - fixed (sbyte* __dsl_file = file) - { - return (void*)LoadFile(__dsl_file, __dsl_datasize); - } - } + public static Ptr GetCurrentCameraDriver() => + Underlying.Value!.GetCurrentCameraDriver(); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] nuint* datasize, - [NativeTypeName("bool")] byte closeio - ) => Underlying.Value!.LoadFileIO(src, datasize, closeio); + public static sbyte* GetCurrentCameraDriverRaw() => + Underlying.Value!.GetCurrentCameraDriverRaw(); + [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] Ref datasize, - [NativeTypeName("bool")] MaybeBool closeio - ) - { - fixed (nuint* __dsl_datasize = datasize) - { - return (void*)LoadFileIO(src, __dsl_datasize, (byte)closeio); - } - } + public static Ptr GetCurrentDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetCurrentDisplayMode(displayID); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.LoadFunction(handle, name); + public static DisplayMode* GetCurrentDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetCurrentDisplayModeRaw(displayID); - [return: NativeTypeName("SDL_FunctionPointer")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (FunctionPointer)LoadFunction(handle, __dsl_name); - } - } + public static DisplayOrientation GetCurrentDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetCurrentDisplayOrientation(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SharedObjectHandle LoadObject( - [NativeTypeName("const char *")] sbyte* sofile - ) => Underlying.Value!.LoadObject(sofile); + public static byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => + Underlying.Value!.GetCurrentRenderOutputSize(renderer, w, h); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SharedObjectHandle LoadObject( - [NativeTypeName("const char *")] Ref sofile + public static MaybeBool GetCurrentRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h ) { - fixed (sbyte* __dsl_sofile = sofile) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (SharedObjectHandle)LoadObject(__dsl_sofile); + return (MaybeBool) + (byte)GetCurrentRenderOutputSize(renderer, __dsl_w, __dsl_h); } } + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong GetCurrentThreadID() => Underlying.Value!.GetCurrentThreadID(); + [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LoadWAV( - [NativeTypeName("const char *")] sbyte* path, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => Underlying.Value!.LoadWAV(path, spec, audio_buf, audio_len); + public static byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => + Underlying.Value!.GetCurrentTime(ticks); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LoadWAV( - [NativeTypeName("const char *")] Ref path, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) + public static MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) { - fixed (uint* __dsl_audio_len = audio_len) - fixed (byte** __dsl_audio_buf = audio_buf) - fixed (AudioSpec* __dsl_spec = spec) - fixed (sbyte* __dsl_path = path) + fixed (long* __dsl_ticks = ticks) { - return (MaybeBool) - (byte)LoadWAV(__dsl_path, __dsl_spec, __dsl_audio_buf, __dsl_audio_len); + return (MaybeBool)(byte)GetCurrentTime(__dsl_ticks); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => Underlying.Value!.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); + public static Ptr GetCurrentVideoDriver() => + Underlying.Value!.GetCurrentVideoDriver(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) - { - fixed (uint* __dsl_audio_len = audio_len) - fixed (byte** __dsl_audio_buf = audio_buf) - fixed (AudioSpec* __dsl_spec = spec) - { - return (MaybeBool) - (byte)LoadWAVIO( - src, - (byte)closeio, - __dsl_spec, - __dsl_audio_buf, - __dsl_audio_len - ); - } - } + public static sbyte* GetCurrentVideoDriverRaw() => + Underlying.Value!.GetCurrentVideoDriverRaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LockAudioStream(AudioStreamHandle stream) => - Underlying.Value!.LockAudioStream(stream); + public static CursorHandle GetCursor() => Underlying.Value!.GetCursor(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LockAudioStreamRaw(AudioStreamHandle stream) => - Underlying.Value!.LockAudioStreamRaw(stream); + public static byte GetDateTimeLocalePreferences( + DateFormat* dateFormat, + TimeFormat* timeFormat + ) => Underlying.Value!.GetDateTimeLocalePreferences(dateFormat, timeFormat); - [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockJoysticks() => Underlying.Value!.LockJoysticks(); + public static MaybeBool GetDateTimeLocalePreferences( + Ref dateFormat, + Ref timeFormat + ) + { + fixed (TimeFormat* __dsl_timeFormat = timeFormat) + fixed (DateFormat* __dsl_dateFormat = dateFormat) + { + return (MaybeBool) + (byte)GetDateTimeLocalePreferences(__dsl_dateFormat, __dsl_timeFormat); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockMutex(MutexHandle mutex) => Underlying.Value!.LockMutex(mutex); + public static int GetDayOfWeek(int year, int month, int day) => + Underlying.Value!.GetDayOfWeek(year, month, day); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LockProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.LockProperties(props); + public static int GetDayOfYear(int year, int month, int day) => + Underlying.Value!.GetDayOfYear(year, month, day); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => - Underlying.Value!.LockPropertiesRaw(props); + public static int GetDaysInMonth(int year, int month) => + Underlying.Value!.GetDaysInMonth(year, month); - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockRWLockForReading(RWLockHandle rwlock) => - Underlying.Value!.LockRWLockForReading(rwlock); + public static AssertionHandler GetDefaultAssertionHandler() => + Underlying.Value!.GetDefaultAssertionHandler(); - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockRWLockForWriting(RWLockHandle rwlock) => - Underlying.Value!.LockRWLockForWriting(rwlock); + public static CursorHandle GetDefaultCursor() => Underlying.Value!.GetDefaultCursor(); - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [return: NativeTypeName("SDL_LogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - Underlying.Value!.LockSpinlock(@lock); + public static LogOutputFunction GetDefaultLogOutputFunction() => + Underlying.Value!.GetDefaultLogOutputFunction(); + [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) - { - fixed (int* __dsl_lock = @lock) - { - LockSpinlock(__dsl_lock); - } - } + public static Ptr GetDesktopDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetDesktopDisplayMode(displayID); + + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static DisplayMode* GetDesktopDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetDesktopDisplayModeRaw(displayID); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LockSurface(Surface* surface) => Underlying.Value!.LockSurface(surface); + public static byte GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => Underlying.Value!.GetDisplayBounds(displayID, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LockSurface(Ref surface) + public static MaybeBool GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) { - fixed (Surface* __dsl_surface = surface) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool)(byte)LockSurface(__dsl_surface); + return (MaybeBool)(byte)GetDisplayBounds(displayID, __dsl_rect); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LockTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - void** pixels, - int* pitch - ) => Underlying.Value!.LockTexture(texture, rect, pixels, pitch); + public static float GetDisplayContentScale( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetDisplayContentScale(displayID); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => + Underlying.Value!.GetDisplayForPoint(point); + + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LockTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D pixels, - Ref pitch + public static uint GetDisplayForPoint( + [NativeTypeName("const SDL_Point *")] Ref point ) { - fixed (int* __dsl_pitch = pitch) - fixed (void** __dsl_pixels = pixels) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) + fixed (Point* __dsl_point = point) { - return (MaybeBool) - (byte)LockTexture(__dsl_texture, __dsl_rect, __dsl_pixels, __dsl_pitch); + return (uint)GetDisplayForPoint(__dsl_point); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte LockTextureToSurface( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - Surface** surface - ) => Underlying.Value!.LockTextureToSurface(texture, rect, surface); + public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => + Underlying.Value!.GetDisplayForRect(rect); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool LockTextureToSurface( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D surface - ) + public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) { - fixed (Surface** __dsl_surface = surface) fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) { - return (MaybeBool) - (byte)LockTextureToSurface(__dsl_texture, __dsl_rect, __dsl_surface); + return (uint)GetDisplayForRect(__dsl_rect); } } - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => Underlying.Value!.LogMessageV(category, priority, fmt, ap); + public static uint GetDisplayForWindow(WindowHandle window) => + Underlying.Value!.GetDisplayForWindow(window); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) - { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) - { - LogMessageV(category, priority, __dsl_fmt, __dsl_ap); - } - } + public static Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => + Underlying.Value!.GetDisplayName(displayID); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => Underlying.Value!.MapRGB(format, palette, r, g, b); + public static sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => + Underlying.Value!.GetDisplayNameRaw(displayID); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => + Underlying.Value!.GetDisplayProperties(displayID); + + [return: NativeTypeName("SDL_DisplayID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* GetDisplays(int* count) => Underlying.Value!.GetDisplays(count); + + [return: NativeTypeName("SDL_DisplayID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) + public static Ptr GetDisplays(Ref count) { - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) + fixed (int* __dsl_count = count) { - return (uint)MapRGB(__dsl_format, __dsl_palette, r, g, b); + return (uint*)GetDisplays(__dsl_count); } } - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => Underlying.Value!.MapRgba(format, palette, r, g, b, a); + public static byte GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => Underlying.Value!.GetDisplayUsableBounds(displayID, rect); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + public static MaybeBool GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect ) { - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) + fixed (Rect* __dsl_rect = rect) { - return (uint)MapRgba(__dsl_format, __dsl_palette, r, g, b, a); + return (MaybeBool)(byte)GetDisplayUsableBounds(displayID, __dsl_rect); } } - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapSurfaceRGB( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => Underlying.Value!.MapSurfaceRGB(surface, r, g, b); + public static sbyte* Getenv([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.Getenv(name); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapSurfaceRGB( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) + public static Ptr Getenv([NativeTypeName("const char *")] Ref name) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_name = name) { - return (uint)MapSurfaceRGB(__dsl_surface, r, g, b); + return (sbyte*)Getenv(__dsl_name); } } - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapSurfaceRgba( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => Underlying.Value!.MapSurfaceRgba(surface, r, g, b, a); + public static sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.GetenvUnsafe(name); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint MapSurfaceRgba( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) + public static Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_name = name) { - return (uint)MapSurfaceRgba(__dsl_surface, r, g, b, a); + return (sbyte*)GetenvUnsafe(__dsl_name); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool MaximizeWindow(WindowHandle window) => - Underlying.Value!.MaximizeWindow(window); + public static EnvironmentHandle GetEnvironment() => Underlying.Value!.GetEnvironment(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte MaximizeWindowRaw(WindowHandle window) => - Underlying.Value!.MaximizeWindowRaw(window); + public static sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.GetEnvironmentVariable(env, name); - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void MemoryBarrierAcquireFunction() => - Underlying.Value!.MemoryBarrierAcquireFunction(); + public static Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)GetEnvironmentVariable(env, __dsl_name); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void MemoryBarrierReleaseFunction() => - Underlying.Value!.MemoryBarrierReleaseFunction(); + public static Ptr2D GetEnvironmentVariables(EnvironmentHandle env) => + Underlying.Value!.GetEnvironmentVariables(env); - [return: NativeTypeName("SDL_MetalView")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env) => + Underlying.Value!.GetEnvironmentVariablesRaw(env); + + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr MetalCreateView(WindowHandle window) => - Underlying.Value!.MetalCreateView(window); + public static Ptr GetError() => Underlying.Value!.GetError(); - [return: NativeTypeName("SDL_MetalView")] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* MetalCreateViewRaw(WindowHandle window) => - Underlying.Value!.MetalCreateViewRaw(window); + public static sbyte* GetErrorRaw() => Underlying.Value!.GetErrorRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => - Underlying.Value!.MetalDestroyView(view); + public static byte GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, + void** userdata + ) => Underlying.Value!.GetEventFilter(filter, userdata); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) + public static MaybeBool GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] Ref filter, + Ref2D userdata + ) { - fixed (void* __dsl_view = view) + fixed (void** __dsl_userdata = userdata) + fixed (EventFilter* __dsl_filter = filter) { - MetalDestroyView(__dsl_view); + return (MaybeBool)(byte)GetEventFilter(__dsl_filter, __dsl_userdata); } } - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => - Underlying.Value!.MetalGetLayer(view); + public static float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float default_value + ) => Underlying.Value!.GetFloatProperty(props, name, default_value); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) + public static float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float default_value + ) { - fixed (void* __dsl_view = view) + fixed (sbyte* __dsl_name = name) { - return (void*)MetalGetLayer(__dsl_view); + return (float)GetFloatProperty(props, __dsl_name, default_value); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool MinimizeWindow(WindowHandle window) => - Underlying.Value!.MinimizeWindow(window); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte MinimizeWindowRaw(WindowHandle window) => - Underlying.Value!.MinimizeWindowRaw(window); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte MixAudio( - [NativeTypeName("Uint8 *")] byte* dst, - [NativeTypeName("const Uint8 *")] byte* src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume - ) => Underlying.Value!.MixAudio(dst, src, format, len, volume); + public static DisplayMode** GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int* count + ) => Underlying.Value!.GetFullscreenDisplayModes(displayID, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool MixAudio( - [NativeTypeName("Uint8 *")] Ref dst, - [NativeTypeName("const Uint8 *")] Ref src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume + public static Ptr2D GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref count ) { - fixed (byte* __dsl_src = src) - fixed (byte* __dsl_dst = dst) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)MixAudio(__dsl_dst, __dsl_src, format, len, volume); + return (DisplayMode**)GetFullscreenDisplayModes(displayID, __dsl_count); } } - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void OnApplicationDidEnterBackground() => - Underlying.Value!.OnApplicationDidEnterBackground(); + public static Ptr GetGamepadAppleSFSymbolsNameForAxis( + GamepadHandle gamepad, + GamepadAxis axis + ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void OnApplicationDidEnterForeground() => - Underlying.Value!.OnApplicationDidEnterForeground(); + public static sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( + GamepadHandle gamepad, + GamepadAxis axis + ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void OnApplicationDidReceiveMemoryWarning() => - Underlying.Value!.OnApplicationDidReceiveMemoryWarning(); + public static Ptr GetGamepadAppleSFSymbolsNameForButton( + GamepadHandle gamepad, + GamepadButton button + ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void OnApplicationWillEnterBackground() => - Underlying.Value!.OnApplicationWillEnterBackground(); - - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void OnApplicationWillEnterForeground() => - Underlying.Value!.OnApplicationWillEnterForeground(); + public static sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( + GamepadHandle gamepad, + GamepadButton button + ) => Underlying.Value!.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void OnApplicationWillTerminate() => - Underlying.Value!.OnApplicationWillTerminate(); + public static short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => + Underlying.Value!.GetGamepadAxis(gamepad, axis); - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec - ) => Underlying.Value!.OpenAudioDevice(devid, spec); + public static GamepadAxis GetGamepadAxisFromString( + [NativeTypeName("const char *")] sbyte* str + ) => Underlying.Value!.GetGamepadAxisFromString(str); - [return: NativeTypeName("SDL_AudioDeviceID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec + public static GamepadAxis GetGamepadAxisFromString( + [NativeTypeName("const char *")] Ref str ) { - fixed (AudioSpec* __dsl_spec = spec) + fixed (sbyte* __dsl_str = str) { - return (uint)OpenAudioDevice(devid, __dsl_spec); + return (GamepadAxis)GetGamepadAxisFromString(__dsl_str); } } - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => Underlying.Value!.OpenAudioDeviceStream(devid, spec, callback, userdata); + public static GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => + Underlying.Value!.GetGamepadBindings(gamepad, count); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata + public static Ptr2D GetGamepadBindings( + GamepadHandle gamepad, + Ref count ) { - fixed (void* __dsl_userdata = userdata) - fixed (AudioSpec* __dsl_spec = spec) + fixed (int* __dsl_count = count) { - return (AudioStreamHandle)OpenAudioDeviceStream( - devid, - __dsl_spec, - callback, - __dsl_userdata - ); + return (GamepadBinding**)GetGamepadBindings(gamepad, __dsl_count); } } - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec - ) => Underlying.Value!.OpenCamera(instance_id, spec); + public static MaybeBool GetGamepadButton( + GamepadHandle gamepad, + GamepadButton button + ) => Underlying.Value!.GetGamepadButton(gamepad, button); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] sbyte* str + ) => Underlying.Value!.GetGamepadButtonFromString(str); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] Ref spec + public static GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] Ref str ) { - fixed (CameraSpec* __dsl_spec = spec) + fixed (sbyte* __dsl_str = str) { - return (CameraHandle)OpenCamera(instance_id, __dsl_spec); + return (GamepadButton)GetGamepadButtonFromString(__dsl_str); } } - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => - Underlying.Value!.OpenFileStorage(path); + public static GamepadButtonLabel GetGamepadButtonLabel( + GamepadHandle gamepad, + GamepadButton button + ) => Underlying.Value!.GetGamepadButtonLabel(gamepad, button); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenFileStorage( - [NativeTypeName("const char *")] Ref path - ) - { - fixed (sbyte* __dsl_path = path) - { - return (StorageHandle)OpenFileStorage(__dsl_path); - } - } + public static GamepadButtonLabel GetGamepadButtonLabelForType( + GamepadType type, + GamepadButton button + ) => Underlying.Value!.GetGamepadButtonLabelForType(type, button); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static GamepadHandle OpenGamepad( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.OpenGamepad(instance_id); + public static byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => + Underlying.Value!.GetGamepadButtonRaw(gamepad, button); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => - Underlying.Value!.OpenHaptic(instance_id); + public static JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadConnectionState(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => - Underlying.Value!.OpenHapticFromJoystick(joystick); + public static ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadFirmwareVersion(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static HapticHandle OpenHapticFromMouse() => Underlying.Value!.OpenHapticFromMouse(); + public static GamepadHandle GetGamepadFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadFromID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, - void* userdata - ) => Underlying.Value!.OpenIO(iface, userdata); + public static GamepadHandle GetGamepadFromPlayerIndex(int player_index) => + Underlying.Value!.GetGamepadFromPlayerIndex(player_index); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (IOStreamInterface* __dsl_iface = iface) - { - return (IOStreamHandle)OpenIO(__dsl_iface, __dsl_userdata); - } - } + public static Guid GetGamepadGuidForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadGuidForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static JoystickHandle OpenJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => Underlying.Value!.OpenJoystick(instance_id); + public static uint GetGamepadID(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadID(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => - Underlying.Value!.OpenSensor(instance_id); + public static JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadJoystick(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, - void* userdata - ) => Underlying.Value!.OpenStorage(iface, userdata); + public static Ptr GetGamepadMapping(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadMapping(gamepad); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] Ref iface, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (StorageInterface* __dsl_iface = iface) - { - return (StorageHandle)OpenStorage(__dsl_iface, __dsl_userdata); - } - } + public static Ptr GetGamepadMappingForGuid(Guid guid) => + Underlying.Value!.GetGamepadMappingForGuid(guid); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] sbyte* @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.OpenTitleStorage(@override, props); + public static sbyte* GetGamepadMappingForGuidRaw(Guid guid) => + Underlying.Value!.GetGamepadMappingForGuidRaw(guid); + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] Ref @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) - { - fixed (sbyte* __dsl_override = @override) - { - return (StorageHandle)OpenTitleStorage(__dsl_override, props); - } - } + public static Ptr GetGamepadMappingForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadMappingForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte OpenURL([NativeTypeName("const char *")] sbyte* url) => - Underlying.Value!.OpenURL(url); + public static sbyte* GetGamepadMappingForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadMappingForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) - { - fixed (sbyte* __dsl_url = url) - { - return (MaybeBool)(byte)OpenURL(__dsl_url); - } - } + public static sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadMappingRaw(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.OpenUserStorage(org, app, props); + public static sbyte** GetGamepadMappings(int* count) => + Underlying.Value!.GetGamepadMappings(count); + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) + public static Ptr2D GetGamepadMappings(Ref count) { - fixed (sbyte* __dsl_app = app) - fixed (sbyte* __dsl_org = org) + fixed (int* __dsl_count = count) { - return (StorageHandle)OpenUserStorage(__dsl_org, __dsl_app, props); + return (sbyte**)GetGamepadMappings(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool OutOfMemory() => Underlying.Value!.OutOfMemory(); + public static Ptr GetGamepadName(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadName(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte OutOfMemoryRaw() => Underlying.Value!.OutOfMemoryRaw(); + public static Ptr GetGamepadNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadNameForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PauseAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => Underlying.Value!.PauseAudioDevice(dev); + public static sbyte* GetGamepadNameForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - Underlying.Value!.PauseAudioDeviceRaw(dev); + public static sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadNameRaw(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => - Underlying.Value!.PauseAudioStreamDevice(stream); + public static Ptr GetGamepadPath(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadPath(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => - Underlying.Value!.PauseAudioStreamDeviceRaw(stream); + public static Ptr GetGamepadPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadPathForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PauseHaptic(HapticHandle haptic) => - Underlying.Value!.PauseHaptic(haptic); + public static sbyte* GetGamepadPathForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadPathForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PauseHapticRaw(HapticHandle haptic) => - Underlying.Value!.PauseHapticRaw(haptic); + public static sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadPathRaw(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int PeepEvents( - Event* events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => Underlying.Value!.PeepEvents(events, numevents, action, minType, maxType); + public static int GetGamepadPlayerIndex(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadPlayerIndex(gamepad); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int GetGamepadPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadPlayerIndexForID(instance_id); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => + Underlying.Value!.GetGamepadPowerInfo(gamepad, percent); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int PeepEvents( - Ref events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) + public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) { - fixed (Event* __dsl_events = events) + fixed (int* __dsl_percent = percent) { - return (int)PeepEvents(__dsl_events, numevents, action, minType, maxType); + return (PowerState)GetGamepadPowerInfo(gamepad, __dsl_percent); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PlayHapticRumble( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => Underlying.Value!.PlayHapticRumble(haptic, strength, length); + public static ushort GetGamepadProduct(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadProduct(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PlayHapticRumbleRaw( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => Underlying.Value!.PlayHapticRumbleRaw(haptic, strength, length); + public static ushort GetGamepadProductForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadProductForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PollEvent(Event* @event) => Underlying.Value!.PollEvent(@event); + public static ushort GetGamepadProductVersion(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadProductVersion(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ushort GetGamepadProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadProductVersionForID(instance_id); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetGamepadProperties(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadProperties(gamepad); + + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* GetGamepads(int* count) => Underlying.Value!.GetGamepads(count); + + [return: NativeTypeName("SDL_JoystickID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PollEvent(Ref @event) + public static Ptr GetGamepads(Ref count) { - fixed (Event* __dsl_event = @event) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)PollEvent(__dsl_event); + return (uint*)GetGamepads(__dsl_count); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch, - [NativeTypeName("bool")] byte linear - ) => - Underlying.Value!.PremultiplyAlpha( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch, - linear - ); + public static byte GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + float* data, + int num_values + ) => Underlying.Value!.GetGamepadSensorData(gamepad, type, data, num_values); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch, - [NativeTypeName("bool")] MaybeBool linear + public static MaybeBool GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + Ref data, + int num_values ) { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) + fixed (float* __dsl_data = data) { return (MaybeBool) - (byte)PremultiplyAlpha( - width, - height, - src_format, - __dsl_src, - src_pitch, - dst_format, - __dsl_dst, - dst_pitch, - (byte)linear - ); + (byte)GetGamepadSensorData(gamepad, type, __dsl_data, num_values); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PremultiplySurfaceAlpha( - Surface* surface, - [NativeTypeName("bool")] byte linear - ) => Underlying.Value!.PremultiplySurfaceAlpha(surface, linear); + public static float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => + Underlying.Value!.GetGamepadSensorDataRate(gamepad, type); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PremultiplySurfaceAlpha( - Ref surface, - [NativeTypeName("bool")] MaybeBool linear - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)PremultiplySurfaceAlpha(__dsl_surface, (byte)linear); - } - } + public static Ptr GetGamepadSerial(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadSerial(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void PumpEvents() => Underlying.Value!.PumpEvents(); + public static sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadSerialRaw(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PushEvent(Event* @event) => Underlying.Value!.PushEvent(@event); + public static ulong GetGamepadSteamHandle(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadSteamHandle(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool PushEvent(Ref @event) - { - fixed (Event* __dsl_event = @event) - { - return (MaybeBool)(byte)PushEvent(__dsl_event); - } - } + public static Ptr GetGamepadStringForAxis(GamepadAxis axis) => + Underlying.Value!.GetGamepadStringForAxis(axis); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] void* buf, - int len - ) => Underlying.Value!.PutAudioStreamData(stream, buf, len); + public static sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => + Underlying.Value!.GetGamepadStringForAxisRaw(axis); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] Ref buf, - int len - ) - { - fixed (void* __dsl_buf = buf) - { - return (MaybeBool)(byte)PutAudioStreamData(stream, __dsl_buf, len); - } - } - - [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void Quit() => Underlying.Value!.Quit(); + public static Ptr GetGamepadStringForButton(GamepadButton button) => + Underlying.Value!.GetGamepadStringForButton(button); - [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.QuitSubSystem(flags); + public static sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => + Underlying.Value!.GetGamepadStringForButtonRaw(button); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RaiseWindow(WindowHandle window) => - Underlying.Value!.RaiseWindow(window); + public static Ptr GetGamepadStringForType(GamepadType type) => + Underlying.Value!.GetGamepadStringForType(type); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RaiseWindowRaw(WindowHandle window) => - Underlying.Value!.RaiseWindowRaw(window); + public static sbyte* GetGamepadStringForTypeRaw(GamepadType type) => + Underlying.Value!.GetGamepadStringForTypeRaw(type); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint ReadIO( - IOStreamHandle context, - void* ptr, - [NativeTypeName("size_t")] nuint size - ) => Underlying.Value!.ReadIO(context, ptr, size); + public static byte GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + bool* down, + float* x, + float* y, + float* pressure + ) => + Underlying.Value!.GetGamepadTouchpadFinger( + gamepad, + touchpad, + finger, + down, + x, + y, + pressure + ); - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint ReadIO( - IOStreamHandle context, - Ref ptr, - [NativeTypeName("size_t")] nuint size + public static MaybeBool GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + Ref down, + Ref x, + Ref y, + Ref pressure ) { - fixed (void* __dsl_ptr = ptr) + fixed (float* __dsl_pressure = pressure) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + fixed (bool* __dsl_down = down) { - return (nuint)ReadIO(context, __dsl_ptr, size); + return (MaybeBool) + (byte)GetGamepadTouchpadFinger( + gamepad, + touchpad, + finger, + __dsl_down, + __dsl_x, + __dsl_y, + __dsl_pressure + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS16BE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] short* value - ) => Underlying.Value!.ReadS16BE(src, value); + public static GamepadType GetGamepadType(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadType(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS16BE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value - ) - { - fixed (short* __dsl_value = value) - { - return (MaybeBool)(byte)ReadS16BE(src, __dsl_value); - } - } + public static GamepadType GetGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadTypeForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS16LE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] short* value - ) => Underlying.Value!.ReadS16LE(src, value); + public static GamepadType GetGamepadTypeFromString( + [NativeTypeName("const char *")] sbyte* str + ) => Underlying.Value!.GetGamepadTypeFromString(str); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS16LE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value + public static GamepadType GetGamepadTypeFromString( + [NativeTypeName("const char *")] Ref str ) { - fixed (short* __dsl_value = value) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)ReadS16LE(src, __dsl_value); + return (GamepadType)GetGamepadTypeFromString(__dsl_str); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - Underlying.Value!.ReadS32BE(src, value); + public static ushort GetGamepadVendor(GamepadHandle gamepad) => + Underlying.Value!.GetGamepadVendor(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS32BE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) - { - fixed (int* __dsl_value = value) - { - return (MaybeBool)(byte)ReadS32BE(src, __dsl_value); - } - } + public static ushort GetGamepadVendorForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetGamepadVendorForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - Underlying.Value!.ReadS32LE(src, value); + public static uint GetGlobalMouseState(float* x, float* y) => + Underlying.Value!.GetGlobalMouseState(x, y); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS32LE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) + public static uint GetGlobalMouseState(Ref x, Ref y) { - fixed (int* __dsl_value = value) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) { - return (MaybeBool)(byte)ReadS32LE(src, __dsl_value); + return (uint)GetGlobalMouseState(__dsl_x, __dsl_y); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS64BE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] long* value - ) => Underlying.Value!.ReadS64BE(src, value); + public static uint GetGlobalProperties() => Underlying.Value!.GetGlobalProperties(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS64BE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) - { - fixed (long* __dsl_value = value) - { - return (MaybeBool)(byte)ReadS64BE(src, __dsl_value); - } - } + public static Ptr GetGPUDeviceDriver(GPUDeviceHandle device) => + Underlying.Value!.GetGPUDeviceDriver(device); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS64LE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] long* value - ) => Underlying.Value!.ReadS64LE(src, value); + public static sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device) => + Underlying.Value!.GetGPUDeviceDriverRaw(device); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS64LE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) - { - fixed (long* __dsl_value = value) - { - return (MaybeBool)(byte)ReadS64LE(src, __dsl_value); - } - } + public static Ptr GetGPUDriver(int index) => Underlying.Value!.GetGPUDriver(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => - Underlying.Value!.ReadS8(src, value); + public static sbyte* GetGPUDriverRaw(int index) => Underlying.Value!.GetGPUDriverRaw(index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [return: NativeTypeName("SDL_GPUShaderFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadS8( - IOStreamHandle src, - [NativeTypeName("Sint8 *")] Ref value - ) - { - fixed (sbyte* __dsl_value = value) - { - return (MaybeBool)(byte)ReadS8(src, __dsl_value); - } - } + public static uint GetGPUShaderFormats(GPUDeviceHandle device) => + Underlying.Value!.GetGPUShaderFormats(device); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - void* destination, - [NativeTypeName("Uint64")] ulong length - ) => Underlying.Value!.ReadStorageFile(storage, path, destination, length); + public static GPUTextureFormat GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ) => Underlying.Value!.GetGPUSwapchainTextureFormat(device, window); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static WindowHandle GetGrabbedWindow() => Underlying.Value!.GetGrabbedWindow(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref destination, - [NativeTypeName("Uint64")] ulong length - ) - { - fixed (void* __dsl_destination = destination) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)ReadStorageFile(storage, __dsl_path, __dsl_destination, length); - } - } + public static MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => + Underlying.Value!.GetHapticEffectStatus(haptic, effect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => Underlying.Value!.ReadSurfacePixel(surface, x, y, r, g, b, a); + public static byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => + Underlying.Value!.GetHapticEffectStatusRaw(haptic, effect); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) - { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)ReadSurfacePixel(__dsl_surface, x, y, __dsl_r, __dsl_g, __dsl_b, __dsl_a); - } - } + public static uint GetHapticFeatures(HapticHandle haptic) => + Underlying.Value!.GetHapticFeatures(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadSurfacePixelFloat( - Surface* surface, - int x, - int y, - float* r, - float* g, - float* b, - float* a - ) => Underlying.Value!.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); + public static HapticHandle GetHapticFromID( + [NativeTypeName("SDL_HapticID")] uint instance_id + ) => Underlying.Value!.GetHapticFromID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [return: NativeTypeName("SDL_HapticID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadSurfacePixelFloat( - Ref surface, - int x, - int y, - Ref r, - Ref g, - Ref b, - Ref a - ) - { - fixed (float* __dsl_a = a) - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)ReadSurfacePixelFloat( - __dsl_surface, - x, - y, - __dsl_r, - __dsl_g, - __dsl_b, - __dsl_a - ); - } - } + public static uint GetHapticID(HapticHandle haptic) => + Underlying.Value!.GetHapticID(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU16BE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] ushort* value - ) => Underlying.Value!.ReadU16BE(src, value); + public static Ptr GetHapticName(HapticHandle haptic) => + Underlying.Value!.GetHapticName(haptic); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU16BE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) - { - fixed (ushort* __dsl_value = value) - { - return (MaybeBool)(byte)ReadU16BE(src, __dsl_value); - } - } + public static Ptr GetHapticNameForID( + [NativeTypeName("SDL_HapticID")] uint instance_id + ) => Underlying.Value!.GetHapticNameForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU16LE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] ushort* value - ) => Underlying.Value!.ReadU16LE(src, value); + public static sbyte* GetHapticNameForIDRaw( + [NativeTypeName("SDL_HapticID")] uint instance_id + ) => Underlying.Value!.GetHapticNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU16LE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) - { - fixed (ushort* __dsl_value = value) - { - return (MaybeBool)(byte)ReadU16LE(src, __dsl_value); - } - } + public static sbyte* GetHapticNameRaw(HapticHandle haptic) => + Underlying.Value!.GetHapticNameRaw(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [return: NativeTypeName("SDL_HapticID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU32BE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] uint* value - ) => Underlying.Value!.ReadU32BE(src, value); + public static uint* GetHaptics(int* count) => Underlying.Value!.GetHaptics(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_HapticID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU32BE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) + public static Ptr GetHaptics(Ref count) { - fixed (uint* __dsl_value = value) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)ReadU32BE(src, __dsl_value); + return (uint*)GetHaptics(__dsl_count); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU32LE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] uint* value - ) => Underlying.Value!.ReadU32LE(src, value); + public static sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.GetHint(name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU32LE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) + public static Ptr GetHint([NativeTypeName("const char *")] Ref name) { - fixed (uint* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)ReadU32LE(src, __dsl_value); + return (sbyte*)GetHint(__dsl_name); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU64BE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] ulong* value - ) => Underlying.Value!.ReadU64BE(src, value); + public static byte GetHintBoolean( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value + ) => Underlying.Value!.GetHintBoolean(name, default_value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU64BE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value + public static MaybeBool GetHintBoolean( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value ) { - fixed (ulong* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)ReadU64BE(src, __dsl_value); + return (MaybeBool)(byte)GetHintBoolean(__dsl_name, (byte)default_value); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU64LE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] ulong* value - ) => Underlying.Value!.ReadU64LE(src, value); + public static uint GetIOProperties(IOStreamHandle context) => + Underlying.Value!.GetIOProperties(context); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU64LE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value - ) - { - fixed (ulong* __dsl_value = value) - { - return (MaybeBool)(byte)ReadU64LE(src, __dsl_value); - } - } + public static long GetIOSize(IOStreamHandle context) => + Underlying.Value!.GetIOSize(context); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IOStatus GetIOStatus(IOStreamHandle context) => + Underlying.Value!.GetIOStatus(context); + + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static short GetJoystickAxis(JoystickHandle joystick, int axis) => + Underlying.Value!.GetJoystickAxis(joystick, axis); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => - Underlying.Value!.ReadU8(src, value); + public static byte GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] short* state + ) => Underlying.Value!.GetJoystickAxisInitialState(joystick, axis, state); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReadU8( - IOStreamHandle src, - [NativeTypeName("Uint8 *")] Ref value + public static MaybeBool GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] Ref state ) { - fixed (byte* __dsl_value = value) + fixed (short* __dsl_state = state) { - return (MaybeBool)(byte)ReadU8(src, __dsl_value); + return (MaybeBool) + (byte)GetJoystickAxisInitialState(joystick, axis, __dsl_state); } } - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static uint RegisterEvents(int numevents) => - Underlying.Value!.RegisterEvents(numevents); - - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => - Underlying.Value!.ReleaseCameraFrame(camera, frame); + public static byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => + Underlying.Value!.GetJoystickBall(joystick, ball, dx, dy); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ReleaseCameraFrame(CameraHandle camera, Ref frame) + public static MaybeBool GetJoystickBall( + JoystickHandle joystick, + int ball, + Ref dx, + Ref dy + ) { - fixed (Surface* __dsl_frame = frame) + fixed (int* __dsl_dy = dy) + fixed (int* __dsl_dx = dx) { - ReleaseCameraFrame(camera, __dsl_frame); + return (MaybeBool)(byte)GetJoystickBall(joystick, ball, __dsl_dx, __dsl_dy); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ReloadGamepadMappings() => - Underlying.Value!.ReloadGamepadMappings(); + public static MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => + Underlying.Value!.GetJoystickButton(joystick, button); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ReloadGamepadMappingsRaw() => - Underlying.Value!.ReloadGamepadMappingsRaw(); + public static byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => + Underlying.Value!.GetJoystickButtonRaw(joystick, button); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => Underlying.Value!.RemoveEventWatch(filter, userdata); + public static JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => + Underlying.Value!.GetJoystickConnectionState(joystick); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - RemoveEventWatch(filter, __dsl_userdata); - } - } + public static ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => + Underlying.Value!.GetJoystickFirmwareVersion(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => Underlying.Value!.RemoveHintCallback(name, callback, userdata); + public static JoystickHandle GetJoystickFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickFromID(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_name = name) - { - RemoveHintCallback(__dsl_name, callback, __dsl_userdata); - } - } + public static JoystickHandle GetJoystickFromPlayerIndex(int player_index) => + Underlying.Value!.GetJoystickFromPlayerIndex(player_index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RemovePath([NativeTypeName("const char *")] sbyte* path) => - Underlying.Value!.RemovePath(path); + public static Guid GetJoystickGuid(JoystickHandle joystick) => + Underlying.Value!.GetJoystickGuid(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)RemovePath(__dsl_path); - } - } + public static Guid GetJoystickGuidForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickGuidForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => Underlying.Value!.RemoveStoragePath(storage, path); + public static void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] ushort* vendor, + [NativeTypeName("Uint16 *")] ushort* product, + [NativeTypeName("Uint16 *")] ushort* version, + [NativeTypeName("Uint16 *")] ushort* crc16 + ) => Underlying.Value!.GetJoystickGuidInfo(guid, vendor, product, version, crc16); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path + public static void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] Ref vendor, + [NativeTypeName("Uint16 *")] Ref product, + [NativeTypeName("Uint16 *")] Ref version, + [NativeTypeName("Uint16 *")] Ref crc16 ) { - fixed (sbyte* __dsl_path = path) + fixed (ushort* __dsl_crc16 = crc16) + fixed (ushort* __dsl_version = version) + fixed (ushort* __dsl_product = product) + fixed (ushort* __dsl_vendor = vendor) { - return (MaybeBool)(byte)RemoveStoragePath(storage, __dsl_path); + GetJoystickGuidInfo(guid, __dsl_vendor, __dsl_product, __dsl_version, __dsl_crc16); } } - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [return: NativeTypeName("Uint8")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveSurfaceAlternateImages(Surface* surface) => - Underlying.Value!.RemoveSurfaceAlternateImages(surface); + public static byte GetJoystickHat(JoystickHandle joystick, int hat) => + Underlying.Value!.GetJoystickHat(joystick, hat); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void RemoveSurfaceAlternateImages(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - RemoveSurfaceAlternateImages(__dsl_surface); - } - } + public static uint GetJoystickID(JoystickHandle joystick) => + Underlying.Value!.GetJoystickID(joystick); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => - Underlying.Value!.RemoveTimer(id); + public static Ptr GetJoystickName(JoystickHandle joystick) => + Underlying.Value!.GetJoystickName(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => - Underlying.Value!.RemoveTimerRaw(id); + public static Ptr GetJoystickNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickNameForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenamePath( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => Underlying.Value!.RenamePath(oldpath, newpath); + public static sbyte* GetJoystickNameForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenamePath( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool)(byte)RenamePath(__dsl_oldpath, __dsl_newpath); - } - } + public static sbyte* GetJoystickNameRaw(JoystickHandle joystick) => + Underlying.Value!.GetJoystickNameRaw(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => Underlying.Value!.RenameStoragePath(storage, oldpath, newpath); + public static Ptr GetJoystickPath(JoystickHandle joystick) => + Underlying.Value!.GetJoystickPath(joystick); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool) - (byte)RenameStoragePath(storage, __dsl_oldpath, __dsl_newpath); - } - } + public static Ptr GetJoystickPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickPathForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderClear(RendererHandle renderer) => - Underlying.Value!.RenderClear(renderer); + public static sbyte* GetJoystickPathForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickPathForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderClearRaw(RendererHandle renderer) => - Underlying.Value!.RenderClearRaw(renderer); + public static sbyte* GetJoystickPathRaw(JoystickHandle joystick) => + Underlying.Value!.GetJoystickPathRaw(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderClipEnabled(RendererHandle renderer) => - Underlying.Value!.RenderClipEnabled(renderer); + public static int GetJoystickPlayerIndex(JoystickHandle joystick) => + Underlying.Value!.GetJoystickPlayerIndex(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderClipEnabledRaw(RendererHandle renderer) => - Underlying.Value!.RenderClipEnabledRaw(renderer); + public static int GetJoystickPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickPlayerIndexForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - float* x, - float* y - ) => Underlying.Value!.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); + public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => + Underlying.Value!.GetJoystickPowerInfo(joystick, percent); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - Ref x, - Ref y - ) + public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) + fixed (int* __dsl_percent = percent) { - return (MaybeBool) - (byte)RenderCoordinatesFromWindow( - renderer, - window_x, - window_y, - __dsl_x, - __dsl_y - ); + return (PowerState)GetJoystickPowerInfo(joystick, __dsl_percent); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - float* window_x, - float* window_y - ) => Underlying.Value!.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + public static ushort GetJoystickProduct(JoystickHandle joystick) => + Underlying.Value!.GetJoystickProduct(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - Ref window_x, - Ref window_y - ) - { - fixed (float* __dsl_window_y = window_y) - fixed (float* __dsl_window_x = window_x) - { - return (MaybeBool) - (byte)RenderCoordinatesToWindow(renderer, x, y, __dsl_window_x, __dsl_window_y); - } - } + public static ushort GetJoystickProductForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickProductForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] sbyte* str - ) => Underlying.Value!.RenderDebugText(renderer, x, y, str); + public static ushort GetJoystickProductVersion(JoystickHandle joystick) => + Underlying.Value!.GetJoystickProductVersion(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] Ref str - ) - { - fixed (sbyte* __dsl_str = str) - { - return (MaybeBool)(byte)RenderDebugText(renderer, x, y, __dsl_str); - } - } + public static ushort GetJoystickProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickProductVersionForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => Underlying.Value!.RenderFillRect(renderer, rect); + public static uint GetJoystickProperties(JoystickHandle joystick) => + Underlying.Value!.GetJoystickProperties(joystick); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* GetJoysticks(int* count) => Underlying.Value!.GetJoysticks(count); + + [return: NativeTypeName("SDL_JoystickID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect - ) + public static Ptr GetJoysticks(Ref count) { - fixed (FRect* __dsl_rect = rect) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)RenderFillRect(renderer, __dsl_rect); + return (uint*)GetJoysticks(__dsl_count); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => Underlying.Value!.RenderFillRects(renderer, rects, count); + public static Ptr GetJoystickSerial(JoystickHandle joystick) => + Underlying.Value!.GetJoystickSerial(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) - { - fixed (FRect* __dsl_rects = rects) - { - return (MaybeBool)(byte)RenderFillRects(renderer, __dsl_rects, count); - } - } + public static sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => + Underlying.Value!.GetJoystickSerialRaw(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderGeometry( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, - int num_vertices, - [NativeTypeName("const int *")] int* indices, - int num_indices - ) => - Underlying.Value!.RenderGeometry( - renderer, - texture, - vertices, - num_vertices, - indices, - num_indices - ); + public static JoystickType GetJoystickType(JoystickHandle joystick) => + Underlying.Value!.GetJoystickType(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderGeometry( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_Vertex *")] Ref vertices, - int num_vertices, - [NativeTypeName("const int *")] Ref indices, - int num_indices - ) - { - fixed (int* __dsl_indices = indices) - fixed (Vertex* __dsl_vertices = vertices) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)RenderGeometry( - renderer, - __dsl_texture, - __dsl_vertices, - num_vertices, - __dsl_indices, - num_indices - ); - } - } + public static JoystickType GetJoystickTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickTypeForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderGeometryRaw( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const float *")] float* xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] FColor* color, - int color_stride, - [NativeTypeName("const float *")] float* uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] void* indices, - int num_indices, - int size_indices - ) => - Underlying.Value!.RenderGeometryRaw( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); + public static ushort GetJoystickVendor(JoystickHandle joystick) => + Underlying.Value!.GetJoystickVendor(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderGeometryRaw( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const float *")] Ref xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] Ref color, - int color_stride, - [NativeTypeName("const float *")] Ref uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] Ref indices, - int num_indices, - int size_indices - ) - { - fixed (void* __dsl_indices = indices) - fixed (float* __dsl_uv = uv) - fixed (FColor* __dsl_color = color) - fixed (float* __dsl_xy = xy) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)RenderGeometryRaw( - renderer, - __dsl_texture, - __dsl_xy, - xy_stride, - __dsl_color, - color_stride, - __dsl_uv, - uv_stride, - num_vertices, - __dsl_indices, - num_indices, - size_indices - ); - } - } + public static ushort GetJoystickVendorForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetJoystickVendorForID(instance_id); - [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static WindowHandle GetKeyboardFocus() => Underlying.Value!.GetKeyboardFocus(); + + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderLine( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => Underlying.Value!.RenderLine(renderer, x1, y1, x2, y2); + public static Ptr GetKeyboardNameForID( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => Underlying.Value!.GetKeyboardNameForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderLineRaw( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => Underlying.Value!.RenderLineRaw(renderer, x1, y1, x2, y2); + public static sbyte* GetKeyboardNameForIDRaw( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => Underlying.Value!.GetKeyboardNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [return: NativeTypeName("SDL_KeyboardID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => Underlying.Value!.RenderLines(renderer, points, count); + public static uint* GetKeyboards(int* count) => Underlying.Value!.GetKeyboards(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_KeyboardID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) + public static Ptr GetKeyboards(Ref count) { - fixed (FPoint* __dsl_points = points) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)RenderLines(renderer, __dsl_points, count); + return (uint*)GetKeyboards(__dsl_count); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [return: NativeTypeName("const bool *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => - Underlying.Value!.RenderPoint(renderer, x, y); + public static bool* GetKeyboardState(int* numkeys) => + Underlying.Value!.GetKeyboardState(numkeys); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [return: NativeTypeName("const bool *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderPointRaw(RendererHandle renderer, float x, float y) => - Underlying.Value!.RenderPointRaw(renderer, x, y); + public static Ptr GetKeyboardState(Ref numkeys) + { + fixed (int* __dsl_numkeys = numkeys) + { + return (bool*)GetKeyboardState(__dsl_numkeys); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => Underlying.Value!.RenderPoints(renderer, points, count); + public static uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.GetKeyFromName(name); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_Keycode")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) + public static uint GetKeyFromName([NativeTypeName("const char *")] Ref name) { - fixed (FPoint* __dsl_points = points) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)RenderPoints(renderer, __dsl_points, count); + return (uint)GetKeyFromName(__dsl_name); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] byte key_event + ) => Underlying.Value!.GetKeyFromScancode(scancode, modstate, key_event); + + [return: NativeTypeName("SDL_Keycode")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderPresent(RendererHandle renderer) => - Underlying.Value!.RenderPresent(renderer); + public static uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] MaybeBool key_event + ) => Underlying.Value!.GetKeyFromScancode(scancode, modstate, key_event); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderPresentRaw(RendererHandle renderer) => - Underlying.Value!.RenderPresentRaw(renderer); + public static Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => + Underlying.Value!.GetKeyName(key); - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => Underlying.Value!.RenderReadPixels(renderer, rect); + public static sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => + Underlying.Value!.GetKeyNameRaw(key); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, + void** userdata + ) => Underlying.Value!.GetLogOutputFunction(callback, userdata); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect + public static void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, + Ref2D userdata ) { - fixed (Rect* __dsl_rect = rect) + fixed (void** __dsl_userdata = userdata) + fixed (LogOutputFunction* __dsl_callback = callback) { - return (Surface*)RenderReadPixels(renderer, __dsl_rect); + GetLogOutputFunction(__dsl_callback, __dsl_userdata); } } + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static LogPriority GetLogPriority(int category) => + Underlying.Value!.GetLogPriority(category); + [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => Underlying.Value!.RenderRect(renderer, rect); + public static byte GetMasksForPixelFormat( + PixelFormat format, + int* bpp, + [NativeTypeName("Uint32 *")] uint* Rmask, + [NativeTypeName("Uint32 *")] uint* Gmask, + [NativeTypeName("Uint32 *")] uint* Bmask, + [NativeTypeName("Uint32 *")] uint* Amask + ) => Underlying.Value!.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect + public static MaybeBool GetMasksForPixelFormat( + PixelFormat format, + Ref bpp, + [NativeTypeName("Uint32 *")] Ref Rmask, + [NativeTypeName("Uint32 *")] Ref Gmask, + [NativeTypeName("Uint32 *")] Ref Bmask, + [NativeTypeName("Uint32 *")] Ref Amask ) { - fixed (FRect* __dsl_rect = rect) + fixed (uint* __dsl_Amask = Amask) + fixed (uint* __dsl_Bmask = Bmask) + fixed (uint* __dsl_Gmask = Gmask) + fixed (uint* __dsl_Rmask = Rmask) + fixed (int* __dsl_bpp = bpp) { - return (MaybeBool)(byte)RenderRect(renderer, __dsl_rect); + return (MaybeBool) + (byte)GetMasksForPixelFormat( + format, + __dsl_bpp, + __dsl_Rmask, + __dsl_Gmask, + __dsl_Bmask, + __dsl_Amask + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => Underlying.Value!.RenderRects(renderer, rects, count); + public static int GetMaxHapticEffects(HapticHandle haptic) => + Underlying.Value!.GetMaxHapticEffects(haptic); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int GetMaxHapticEffectsPlaying(HapticHandle haptic) => + Underlying.Value!.GetMaxHapticEffectsPlaying(haptic); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => + Underlying.Value!.GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count + public static void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func ) { - fixed (FRect* __dsl_rects = rects) + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) { - return (MaybeBool)(byte)RenderRects(renderer, __dsl_rects, count); + GetMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [return: NativeTypeName("SDL_MouseID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderTexture( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => Underlying.Value!.RenderTexture(renderer, texture, srcrect, dstrect); + public static uint* GetMice(int* count) => Underlying.Value!.GetMice(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderTexture( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) + public static Ptr GetMice(Ref count) { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_count = count) { - return (MaybeBool) - (byte)RenderTexture(renderer, __dsl_texture, __dsl_srcrect, __dsl_dstrect); + return (uint*)GetMice(__dsl_count); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [return: NativeTypeName("SDL_Keymod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderTexture9Grid( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => - Underlying.Value!.RenderTexture9Grid( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); + public static ushort GetModState() => Underlying.Value!.GetModState(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderTexture9Grid( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) - { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)RenderTexture9Grid( - renderer, - __dsl_texture, - __dsl_srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - __dsl_dstrect - ); - } - } + public static WindowHandle GetMouseFocus() => Underlying.Value!.GetMouseFocus(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderTextureRotated( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] FPoint* center, - FlipMode flip - ) => - Underlying.Value!.RenderTextureRotated( - renderer, - texture, - srcrect, - dstrect, - angle, - center, - flip - ); + public static Ptr GetMouseNameForID( + [NativeTypeName("SDL_MouseID")] uint instance_id + ) => Underlying.Value!.GetMouseNameForID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderTextureRotated( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] Ref center, - FlipMode flip - ) - { - fixed (FPoint* __dsl_center = center) - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)RenderTextureRotated( - renderer, - __dsl_texture, - __dsl_srcrect, - __dsl_dstrect, - angle, - __dsl_center, - flip - ); - } - } + public static sbyte* GetMouseNameForIDRaw( + [NativeTypeName("SDL_MouseID")] uint instance_id + ) => Underlying.Value!.GetMouseNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderTextureTiled( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => Underlying.Value!.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + public static uint GetMouseState(float* x, float* y) => + Underlying.Value!.GetMouseState(x, y); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderTextureTiled( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) + public static uint GetMouseState(Ref x, Ref y) { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) { - return (MaybeBool) - (byte)RenderTextureTiled( - renderer, - __dsl_texture, - __dsl_srcrect, - scale, - __dsl_dstrect - ); + return (uint)GetMouseState(__dsl_x, __dsl_y); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RenderViewportSet(RendererHandle renderer) => - Underlying.Value!.RenderViewportSet(renderer); + public static DisplayOrientation GetNaturalDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => Underlying.Value!.GetNaturalDisplayOrientation(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAllocations")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RenderViewportSetRaw(RendererHandle renderer) => - Underlying.Value!.RenderViewportSetRaw(renderer); + public static int GetNumAllocations() => Underlying.Value!.GetNumAllocations(); - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertState ReportAssertion( - AssertData* data, - [NativeTypeName("const char *")] sbyte* func, - [NativeTypeName("const char *")] sbyte* file, - int line - ) => Underlying.Value!.ReportAssertion(data, func, file, line); + public static int GetNumAudioDrivers() => Underlying.Value!.GetNumAudioDrivers(); + + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long default_value + ) => Underlying.Value!.GetNumberProperty(props, name, default_value); + [return: NativeTypeName("Sint64")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static AssertState ReportAssertion( - Ref data, - [NativeTypeName("const char *")] Ref func, - [NativeTypeName("const char *")] Ref file, - int line + public static long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long default_value ) { - fixed (sbyte* __dsl_file = file) - fixed (sbyte* __dsl_func = func) - fixed (AssertData* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { - return (AssertState)ReportAssertion(__dsl_data, __dsl_func, __dsl_file, line); + return (long)GetNumberProperty(props, __dsl_name, default_value); } } - [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ResetAssertionReport() => Underlying.Value!.ResetAssertionReport(); + public static int GetNumCameraDrivers() => Underlying.Value!.GetNumCameraDrivers(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ResetHint([NativeTypeName("const char *")] sbyte* name) => - Underlying.Value!.ResetHint(name); + public static int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => + Underlying.Value!.GetNumGamepadTouchpadFingers(gamepad, touchpad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)ResetHint(__dsl_name); - } - } + public static int GetNumGamepadTouchpads(GamepadHandle gamepad) => + Underlying.Value!.GetNumGamepadTouchpads(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGPUDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ResetHints() => Underlying.Value!.ResetHints(); + public static int GetNumGPUDrivers() => Underlying.Value!.GetNumGPUDrivers(); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ResetKeyboard() => Underlying.Value!.ResetKeyboard(); + public static int GetNumHapticAxes(HapticHandle haptic) => + Underlying.Value!.GetNumHapticAxes(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ResetLogPriorities() => Underlying.Value!.ResetLogPriorities(); + public static int GetNumJoystickAxes(JoystickHandle joystick) => + Underlying.Value!.GetNumJoystickAxes(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RestoreWindow(WindowHandle window) => - Underlying.Value!.RestoreWindow(window); + public static int GetNumJoystickBalls(JoystickHandle joystick) => + Underlying.Value!.GetNumJoystickBalls(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RestoreWindowRaw(WindowHandle window) => - Underlying.Value!.RestoreWindowRaw(window); + public static int GetNumJoystickButtons(JoystickHandle joystick) => + Underlying.Value!.GetNumJoystickButtons(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ResumeAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => Underlying.Value!.ResumeAudioDevice(dev); + public static int GetNumJoystickHats(JoystickHandle joystick) => + Underlying.Value!.GetNumJoystickHats(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - Underlying.Value!.ResumeAudioDeviceRaw(dev); + public static int GetNumLogicalCPUCores() => Underlying.Value!.GetNumLogicalCPUCores(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => - Underlying.Value!.ResumeAudioStreamDevice(stream); + public static int GetNumRenderDrivers() => Underlying.Value!.GetNumRenderDrivers(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => - Underlying.Value!.ResumeAudioStreamDeviceRaw(stream); + public static int GetNumVideoDrivers() => Underlying.Value!.GetNumVideoDrivers(); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => + Underlying.Value!.GetOriginalMemoryFunctions( + malloc_func, + calloc_func, + realloc_func, + free_func + ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ResumeHaptic(HapticHandle haptic) => - Underlying.Value!.ResumeHaptic(haptic); + public static void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) + { + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) + { + GetOriginalMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ResumeHapticRaw(HapticHandle haptic) => - Underlying.Value!.ResumeHapticRaw(haptic); + public static byte GetPathInfo( + [NativeTypeName("const char *")] sbyte* path, + PathInfo* info + ) => Underlying.Value!.GetPathInfo(path, info); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RumbleGamepad( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleGamepad( - gamepad, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static MaybeBool GetPathInfo( + [NativeTypeName("const char *")] Ref path, + Ref info + ) + { + fixed (PathInfo* __dsl_info = info) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)GetPathInfo(__dsl_path, __dsl_info); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RumbleGamepadRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleGamepadRaw( - gamepad, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static ulong GetPerformanceCounter() => Underlying.Value!.GetPerformanceCounter(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RumbleGamepadTriggers( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleGamepadTriggers( - gamepad, - left_rumble, - right_rumble, - duration_ms - ); + public static ulong GetPerformanceFrequency() => + Underlying.Value!.GetPerformanceFrequency(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RumbleGamepadTriggersRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleGamepadTriggersRaw( - gamepad, - left_rumble, - right_rumble, - duration_ms - ); + public static Ptr GetPixelFormatDetails(PixelFormat format) => + Underlying.Value!.GetPixelFormatDetails(format); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RumbleJoystick( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleJoystick( - joystick, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => + Underlying.Value!.GetPixelFormatDetailsRaw(format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RumbleJoystickRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleJoystickRaw( - joystick, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static PixelFormat GetPixelFormatForMasks( + int bpp, + [NativeTypeName("Uint32")] uint Rmask, + [NativeTypeName("Uint32")] uint Gmask, + [NativeTypeName("Uint32")] uint Bmask, + [NativeTypeName("Uint32")] uint Amask + ) => Underlying.Value!.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RumbleJoystickTriggers( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleJoystickTriggers( - joystick, - left_rumble, - right_rumble, - duration_ms - ); + public static Ptr GetPixelFormatName(PixelFormat format) => + Underlying.Value!.GetPixelFormatName(format); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RumbleJoystickTriggersRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - Underlying.Value!.RumbleJoystickTriggersRaw( - joystick, - left_rumble, - right_rumble, - duration_ms - ); + public static sbyte* GetPixelFormatNameRaw(PixelFormat format) => + Underlying.Value!.GetPixelFormatNameRaw(format); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool RunHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => Underlying.Value!.RunHapticEffect(haptic, effect, iterations); + public static Ptr GetPlatform() => Underlying.Value!.GetPlatform(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte RunHapticEffectRaw( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => Underlying.Value!.RunHapticEffectRaw(haptic, effect, iterations); + public static sbyte* GetPlatformRaw() => Underlying.Value!.GetPlatformRaw(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SaveBMP( - Surface* surface, - [NativeTypeName("const char *")] sbyte* file - ) => Underlying.Value!.SaveBMP(surface, file); + public static void* GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* default_value + ) => Underlying.Value!.GetPointerProperty(props, name, default_value); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SaveBMP( - Ref surface, - [NativeTypeName("const char *")] Ref file + public static Ptr GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref default_value ) { - fixed (sbyte* __dsl_file = file) - fixed (Surface* __dsl_surface = surface) + fixed (void* __dsl_default_value = default_value) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)SaveBMP(__dsl_surface, __dsl_file); + return (void*)GetPointerProperty(props, __dsl_name, __dsl_default_value); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SaveBMPIO( - Surface* surface, - IOStreamHandle dst, - [NativeTypeName("bool")] byte closeio - ) => Underlying.Value!.SaveBMPIO(surface, dst, closeio); + public static PowerState GetPowerInfo(int* seconds, int* percent) => + Underlying.Value!.GetPowerInfo(seconds, percent); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SaveBMPIO( - Ref surface, - IOStreamHandle dst, - [NativeTypeName("bool")] MaybeBool closeio - ) + public static PowerState GetPowerInfo(Ref seconds, Ref percent) { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)SaveBMPIO(__dsl_surface, dst, (byte)closeio); + fixed (int* __dsl_percent = percent) + fixed (int* __dsl_seconds = seconds) + { + return (PowerState)GetPowerInfo(__dsl_seconds, __dsl_percent); } } - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Surface* ScaleSurface( - Surface* surface, - int width, - int height, - ScaleMode scaleMode - ) => Underlying.Value!.ScaleSurface(surface, width, height, scaleMode); + public static Locale** GetPreferredLocales(int* count) => + Underlying.Value!.GetPreferredLocales(count); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr ScaleSurface( - Ref surface, - int width, - int height, - ScaleMode scaleMode - ) + public static Ptr2D GetPreferredLocales(Ref count) { - fixed (Surface* __dsl_surface = surface) + fixed (int* __dsl_count = count) { - return (Surface*)ScaleSurface(__dsl_surface, width, height, scaleMode); + return (Locale**)GetPreferredLocales(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* GetPrefPath( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app + ) => Underlying.Value!.GetPrefPath(org, app); + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ScreenKeyboardShown(WindowHandle window) => - Underlying.Value!.ScreenKeyboardShown(window); + public static Ptr GetPrefPath( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app + ) + { + fixed (sbyte* __dsl_app = app) + fixed (sbyte* __dsl_org = org) + { + return (sbyte*)GetPrefPath(__dsl_org, __dsl_app); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ScreenKeyboardShownRaw(WindowHandle window) => - Underlying.Value!.ScreenKeyboardShownRaw(window); + public static uint GetPrimaryDisplay() => Underlying.Value!.GetPrimaryDisplay(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ScreenSaverEnabled() => - Underlying.Value!.ScreenSaverEnabled(); + public static Ptr GetPrimarySelectionText() => + Underlying.Value!.GetPrimarySelectionText(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ScreenSaverEnabledRaw() => Underlying.Value!.ScreenSaverEnabledRaw(); + public static sbyte* GetPrimarySelectionTextRaw() => + Underlying.Value!.GetPrimarySelectionTextRaw(); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessInput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long SeekIO( - IOStreamHandle context, - [NativeTypeName("Sint64")] long offset, - IOWhence whence - ) => Underlying.Value!.SeekIO(context, offset, whence); + public static IOStreamHandle GetProcessInput(ProcessHandle process) => + Underlying.Value!.GetProcessInput(process); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessOutput")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] void* data, - int size - ) => Underlying.Value!.SendGamepadEffect(gamepad, data, size); + public static IOStreamHandle GetProcessOutput(ProcessHandle process) => + Underlying.Value!.GetProcessOutput(process); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetProcessProperties(ProcessHandle process) => + Underlying.Value!.GetProcessProperties(process); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.GetPropertyType(props, name); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] Ref data, - int size + public static PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name ) { - fixed (void* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)SendGamepadEffect(gamepad, __dsl_data, size); + return (PropertyType)GetPropertyType(props, __dsl_name); } } + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GamepadType GetRealGamepadType(GamepadHandle gamepad) => + Underlying.Value!.GetRealGamepadType(gamepad); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GamepadType GetRealGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.GetRealGamepadTypeForID(instance_id); + [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] void* data, - int size - ) => Underlying.Value!.SendJoystickEffect(joystick, data, size); + public static byte GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int* X1, + int* Y1, + int* X2, + int* Y2 + ) => Underlying.Value!.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] Ref data, - int size + public static MaybeBool GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 ) { - fixed (void* __dsl_data = data) + fixed (int* __dsl_Y2 = Y2) + fixed (int* __dsl_X2 = X2) + fixed (int* __dsl_Y1 = Y1) + fixed (int* __dsl_X1 = X1) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool)(byte)SendJoystickEffect(joystick, __dsl_data, size); + return (MaybeBool) + (byte)GetRectAndLineIntersection( + __dsl_rect, + __dsl_X1, + __dsl_Y1, + __dsl_X2, + __dsl_Y2 + ); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] float* data, - int num_values - ) => - Underlying.Value!.SendJoystickVirtualSensorData( - joystick, - type, - sensor_timestamp, - data, - num_values - ); + public static byte GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* rect, + float* X1, + float* Y1, + float* X2, + float* Y2 + ) => Underlying.Value!.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] Ref data, - int num_values + public static MaybeBool GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 ) { - fixed (float* __dsl_data = data) + fixed (float* __dsl_Y2 = Y2) + fixed (float* __dsl_X2 = X2) + fixed (float* __dsl_Y1 = Y1) + fixed (float* __dsl_X1 = X1) + fixed (FRect* __dsl_rect = rect) { return (MaybeBool) - (byte)SendJoystickVirtualSensorData( - joystick, - type, - sensor_timestamp, - __dsl_data, - num_values + (byte)GetRectAndLineIntersectionFloat( + __dsl_rect, + __dsl_X1, + __dsl_Y1, + __dsl_X2, + __dsl_Y2 ); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAppMetadata( - [NativeTypeName("const char *")] sbyte* appname, - [NativeTypeName("const char *")] sbyte* appversion, - [NativeTypeName("const char *")] sbyte* appidentifier - ) => Underlying.Value!.SetAppMetadata(appname, appversion, appidentifier); + public static byte GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Point* points, + int count, + [NativeTypeName("const SDL_Rect *")] Rect* clip, + Rect* result + ) => Underlying.Value!.GetRectEnclosingPoints(points, count, clip, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAppMetadata( - [NativeTypeName("const char *")] Ref appname, - [NativeTypeName("const char *")] Ref appversion, - [NativeTypeName("const char *")] Ref appidentifier + public static MaybeBool GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Ref points, + int count, + [NativeTypeName("const SDL_Rect *")] Ref clip, + Ref result ) { - fixed (sbyte* __dsl_appidentifier = appidentifier) - fixed (sbyte* __dsl_appversion = appversion) - fixed (sbyte* __dsl_appname = appname) + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_clip = clip) + fixed (Point* __dsl_points = points) { return (MaybeBool) - (byte)SetAppMetadata(__dsl_appname, __dsl_appversion, __dsl_appidentifier); + (byte)GetRectEnclosingPoints(__dsl_points, count, __dsl_clip, __dsl_result); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAppMetadataProperty( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => Underlying.Value!.SetAppMetadataProperty(name, value); + public static byte GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count, + [NativeTypeName("const SDL_FRect *")] FRect* clip, + FRect* result + ) => Underlying.Value!.GetRectEnclosingPointsFloat(points, count, clip, result); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value + public static MaybeBool GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count, + [NativeTypeName("const SDL_FRect *")] Ref clip, + Ref result ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_clip = clip) + fixed (FPoint* __dsl_points = points) { - return (MaybeBool)(byte)SetAppMetadataProperty(__dsl_name, __dsl_value); + return (MaybeBool) + (byte)GetRectEnclosingPointsFloat( + __dsl_points, + count, + __dsl_clip, + __dsl_result + ); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - void* userdata - ) => Underlying.Value!.SetAssertionHandler(handler, userdata); + public static byte GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => Underlying.Value!.GetRectIntersection(A, B, result); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - Ref userdata + public static MaybeBool GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result ) { - fixed (void* __dsl_userdata = userdata) + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) { - SetAssertionHandler(handler, __dsl_userdata); + return (MaybeBool)(byte)GetRectIntersection(__dsl_A, __dsl_B, __dsl_result); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int SetAtomicInt(AtomicInt* a, int v) => Underlying.Value!.SetAtomicInt(a, v); + public static byte GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => Underlying.Value!.GetRectIntersectionFloat(A, B, result); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static int SetAtomicInt(Ref a, int v) + public static MaybeBool GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) { - fixed (AtomicInt* __dsl_a = a) + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) { - return (int)SetAtomicInt(__dsl_a, v); + return (MaybeBool) + (byte)GetRectIntersectionFloat(__dsl_A, __dsl_B, __dsl_result); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void* SetAtomicPointer(void** a, void* v) => - Underlying.Value!.SetAtomicPointer(a, v); + public static byte GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => Underlying.Value!.GetRectUnion(A, B, result); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Ptr SetAtomicPointer(Ref2D a, Ref v) + public static MaybeBool GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) { - fixed (void* __dsl_v = v) - fixed (void** __dsl_a = a) + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) { - return (void*)SetAtomicPointer(__dsl_a, __dsl_v); + return (MaybeBool)(byte)GetRectUnion(__dsl_A, __dsl_B, __dsl_result); } } - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => - Underlying.Value!.SetAtomicU32(a, v); + public static byte GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => Underlying.Value!.GetRectUnionFloat(A, B, result); - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) + public static MaybeBool GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) { - fixed (AtomicU32* __dsl_a = a) + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) { - return (uint)SetAtomicU32(__dsl_a, v); + return (MaybeBool)(byte)GetRectUnionFloat(__dsl_A, __dsl_B, __dsl_result); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioDeviceGain( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => Underlying.Value!.SetAudioDeviceGain(devid, gain); + public static uint GetRelativeMouseState(float* x, float* y) => + Underlying.Value!.GetRelativeMouseState(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioDeviceGainRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => Underlying.Value!.SetAudioDeviceGainRaw(devid, gain); + public static uint GetRelativeMouseState(Ref x, Ref y) + { + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + { + return (uint)GetRelativeMouseState(__dsl_x, __dsl_y); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - void* userdata - ) => Underlying.Value!.SetAudioPostmixCallback(devid, callback, userdata); + public static byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => + Underlying.Value!.GetRenderClipRect(renderer, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - Ref userdata - ) + public static MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) { - fixed (void* __dsl_userdata = userdata) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte)SetAudioPostmixCallback(devid, callback, __dsl_userdata); + return (MaybeBool)(byte)GetRenderClipRect(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => Underlying.Value!.SetAudioStreamFormat(stream, src_spec, dst_spec); + public static byte GetRenderColorScale(RendererHandle renderer, float* scale) => + Underlying.Value!.GetRenderColorScale(renderer, scale); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) + public static MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) + fixed (float* __dsl_scale = scale) { - return (MaybeBool) - (byte)SetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); + return (MaybeBool)(byte)GetRenderColorScale(renderer, __dsl_scale); } } [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetAudioStreamFrequencyRatio( - AudioStreamHandle stream, - float ratio - ) => Underlying.Value!.SetAudioStreamFrequencyRatio(stream, ratio); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => - Underlying.Value!.SetAudioStreamFrequencyRatioRaw(stream, ratio); + public static byte GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => Underlying.Value!.GetRenderDrawBlendMode(renderer, blendMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => - Underlying.Value!.SetAudioStreamGain(stream, gain); + public static MaybeBool GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) + { + fixed (BlendMode* __dsl_blendMode = blendMode) + { + return (MaybeBool)(byte)GetRenderDrawBlendMode(renderer, __dsl_blendMode); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => - Underlying.Value!.SetAudioStreamGainRaw(stream, gain); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => Underlying.Value!.SetAudioStreamGetCallback(stream, callback, userdata); + public static byte GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => Underlying.Value!.GetRenderDrawColor(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata + public static MaybeBool GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a ) { - fixed (void* __dsl_userdata = userdata) + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) { return (MaybeBool) - (byte)SetAudioStreamGetCallback(stream, callback, __dsl_userdata); + (byte)GetRenderDrawColor(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => Underlying.Value!.SetAudioStreamInputChannelMap(stream, chmap, count); + public static byte GetRenderDrawColorFloat( + RendererHandle renderer, + float* r, + float* g, + float* b, + float* a + ) => Underlying.Value!.GetRenderDrawColorFloat(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count + public static MaybeBool GetRenderDrawColorFloat( + RendererHandle renderer, + Ref r, + Ref g, + Ref b, + Ref a ) { - fixed (int* __dsl_chmap = chmap) + fixed (float* __dsl_a = a) + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) { return (MaybeBool) - (byte)SetAudioStreamInputChannelMap(stream, __dsl_chmap, count); + (byte)GetRenderDrawColorFloat(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => Underlying.Value!.SetAudioStreamOutputChannelMap(stream, chmap, count); + public static Ptr GetRenderDriver(int index) => + Underlying.Value!.GetRenderDriver(index); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) - { - fixed (int* __dsl_chmap = chmap) - { - return (MaybeBool) - (byte)SetAudioStreamOutputChannelMap(stream, __dsl_chmap, count); - } - } + public static sbyte* GetRenderDriverRaw(int index) => + Underlying.Value!.GetRenderDriverRaw(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => Underlying.Value!.SetAudioStreamPutCallback(stream, callback, userdata); + public static RendererHandle GetRenderer(WindowHandle window) => + Underlying.Value!.GetRenderer(window); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static RendererHandle GetRendererFromTexture(Texture* texture) => + Underlying.Value!.GetRendererFromTexture(texture); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) + public static RendererHandle GetRendererFromTexture(Ref texture) { - fixed (void* __dsl_userdata = userdata) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool) - (byte)SetAudioStreamPutCallback(stream, callback, __dsl_userdata); + return (RendererHandle)GetRendererFromTexture(__dsl_texture); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte value - ) => Underlying.Value!.SetBooleanProperty(props, name, value); + public static Ptr GetRendererName(RendererHandle renderer) => + Underlying.Value!.GetRendererName(renderer); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)SetBooleanProperty(props, __dsl_name, (byte)value); - } - } + public static sbyte* GetRendererNameRaw(RendererHandle renderer) => + Underlying.Value!.GetRendererNameRaw(renderer); + + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint GetRendererProperties(RendererHandle renderer) => + Underlying.Value!.GetRendererProperties(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - void* userdata, - [NativeTypeName("const char **")] sbyte** mime_types, - [NativeTypeName("size_t")] nuint num_mime_types - ) => - Underlying.Value!.SetClipboardData( - callback, - cleanup, - userdata, - mime_types, - num_mime_types - ); + public static byte GetRenderLogicalPresentation( + RendererHandle renderer, + int* w, + int* h, + RendererLogicalPresentation* mode + ) => Underlying.Value!.GetRenderLogicalPresentation(renderer, w, h, mode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - Ref userdata, - [NativeTypeName("const char **")] Ref2D mime_types, - [NativeTypeName("size_t")] nuint num_mime_types + public static MaybeBool GetRenderLogicalPresentation( + RendererHandle renderer, + Ref w, + Ref h, + Ref mode ) { - fixed (sbyte** __dsl_mime_types = mime_types) - fixed (void* __dsl_userdata = userdata) + fixed (RendererLogicalPresentation* __dsl_mode = mode) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { return (MaybeBool) - (byte)SetClipboardData( - callback, - cleanup, - __dsl_userdata, - __dsl_mime_types, - num_mime_types - ); + (byte)GetRenderLogicalPresentation(renderer, __dsl_w, __dsl_h, __dsl_mode); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => - Underlying.Value!.SetClipboardText(text); + public static byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => + Underlying.Value!.GetRenderLogicalPresentationRect(renderer, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetClipboardText( - [NativeTypeName("const char *")] Ref text + public static MaybeBool GetRenderLogicalPresentationRect( + RendererHandle renderer, + Ref rect ) { - fixed (sbyte* __dsl_text = text) + fixed (FRect* __dsl_rect = rect) { - return (MaybeBool)(byte)SetClipboardText(__dsl_text); + return (MaybeBool) + (byte)GetRenderLogicalPresentationRect(renderer, __dsl_rect); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => - Underlying.Value!.SetCurrentThreadPriority(priority); + public static Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => + Underlying.Value!.GetRenderMetalCommandEncoder(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => - Underlying.Value!.SetCurrentThreadPriorityRaw(priority); + public static void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => + Underlying.Value!.GetRenderMetalCommandEncoderRaw(renderer); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetCursor(CursorHandle cursor) => - Underlying.Value!.SetCursor(cursor); + public static Ptr GetRenderMetalLayer(RendererHandle renderer) => + Underlying.Value!.GetRenderMetalLayer(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetCursorRaw(CursorHandle cursor) => - Underlying.Value!.SetCursorRaw(cursor); + public static void* GetRenderMetalLayerRaw(RendererHandle renderer) => + Underlying.Value!.GetRenderMetalLayerRaw(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetErrorV( - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => Underlying.Value!.SetErrorV(fmt, ap); + public static byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => + Underlying.Value!.GetRenderOutputSize(renderer, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetErrorV( - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap + public static MaybeBool GetRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h ) { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (MaybeBool)(byte)SetErrorV(__dsl_fmt, __dsl_ap); + return (MaybeBool)(byte)GetRenderOutputSize(renderer, __dsl_w, __dsl_h); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] byte enabled - ) => Underlying.Value!.SetEventEnabled(type, enabled); - - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.SetEventEnabled(type, enabled); - - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => Underlying.Value!.SetEventFilter(filter, userdata); + public static byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => + Underlying.Value!.GetRenderSafeArea(renderer, rect); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) + public static MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) { - fixed (void* __dsl_userdata = userdata) + fixed (Rect* __dsl_rect = rect) { - SetEventFilter(filter, __dsl_userdata); + return (MaybeBool)(byte)GetRenderSafeArea(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float value - ) => Underlying.Value!.SetFloatProperty(props, name, value); + public static byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => + Underlying.Value!.GetRenderScale(renderer, scaleX, scaleY); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float value + public static MaybeBool GetRenderScale( + RendererHandle renderer, + Ref scaleX, + Ref scaleY ) { - fixed (sbyte* __dsl_name = name) + fixed (float* __dsl_scaleY = scaleY) + fixed (float* __dsl_scaleX = scaleX) { - return (MaybeBool)(byte)SetFloatProperty(props, __dsl_name, value); + return (MaybeBool)(byte)GetRenderScale(renderer, __dsl_scaleX, __dsl_scaleY); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => - Underlying.Value!.SetGamepadEventsEnabled(enabled); - - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static void SetGamepadEventsEnabled( - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.SetGamepadEventsEnabled(enabled); - - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetGamepadLED( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => Underlying.Value!.SetGamepadLED(gamepad, red, green, blue); + public static Ptr GetRenderTarget(RendererHandle renderer) => + Underlying.Value!.GetRenderTarget(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetGamepadLEDRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => Underlying.Value!.SetGamepadLEDRaw(gamepad, red, green, blue); + public static Texture* GetRenderTargetRaw(RendererHandle renderer) => + Underlying.Value!.GetRenderTargetRaw(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] sbyte* mapping - ) => Underlying.Value!.SetGamepadMapping(instance_id, mapping); + public static byte GetRenderViewport(RendererHandle renderer, Rect* rect) => + Underlying.Value!.GetRenderViewport(renderer, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] Ref mapping - ) + public static MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) { - fixed (sbyte* __dsl_mapping = mapping) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool)(byte)SetGamepadMapping(instance_id, __dsl_mapping); + return (MaybeBool)(byte)GetRenderViewport(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetGamepadPlayerIndex( - GamepadHandle gamepad, - int player_index - ) => Underlying.Value!.SetGamepadPlayerIndex(gamepad, player_index); + public static byte GetRenderVSync(RendererHandle renderer, int* vsync) => + Underlying.Value!.GetRenderVSync(renderer, vsync); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => - Underlying.Value!.SetGamepadPlayerIndexRaw(gamepad, player_index); + public static MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) + { + fixed (int* __dsl_vsync = vsync) + { + return (MaybeBool)(byte)GetRenderVSync(renderer, __dsl_vsync); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] byte enabled - ) => Underlying.Value!.SetGamepadSensorEnabled(gamepad, type, enabled); + public static WindowHandle GetRenderWindow(RendererHandle renderer) => + Underlying.Value!.GetRenderWindow(renderer); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.SetGamepadSensorEnabled(gamepad, type, enabled); + public static Ptr GetRevision() => Underlying.Value!.GetRevision(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => - Underlying.Value!.SetHapticAutocenter(haptic, autocenter); + public static sbyte* GetRevisionRaw() => Underlying.Value!.GetRevisionRaw(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => - Underlying.Value!.SetHapticAutocenterRaw(haptic, autocenter); + public static void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => Underlying.Value!.GetRGB(pixel, format, palette, r, g, b); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetHapticGain(HapticHandle haptic, int gain) => - Underlying.Value!.SetHapticGain(haptic, gain); + public static void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) + { + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + GetRGB(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetHapticGainRaw(HapticHandle haptic, int gain) => - Underlying.Value!.SetHapticGainRaw(haptic, gain); + public static void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => Underlying.Value!.GetRgba(pixel, format, palette, r, g, b, a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetHint( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => Underlying.Value!.SetHint(name, value); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetHint( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value + public static void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) { - return (MaybeBool)(byte)SetHint(__dsl_name, __dsl_value); + GetRgba(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b, __dsl_a); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetHintWithPriority( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value, - HintPriority priority - ) => Underlying.Value!.SetHintWithPriority(name, value, priority); + public static Sandbox GetSandbox() => Underlying.Value!.GetSandbox(); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] ushort* modstate + ) => Underlying.Value!.GetScancodeFromKey(key, modstate); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetHintWithPriority( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value, - HintPriority priority + public static Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] Ref modstate ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (ushort* __dsl_modstate = modstate) { - return (MaybeBool) - (byte)SetHintWithPriority(__dsl_name, __dsl_value, priority); + return (Scancode)GetScancodeFromKey(key, __dsl_modstate); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetInitialized( - InitState* state, - [NativeTypeName("bool")] byte initialized - ) => Underlying.Value!.SetInitialized(state, initialized); + public static Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.GetScancodeFromName(name); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetInitialized( - Ref state, - [NativeTypeName("bool")] MaybeBool initialized - ) + public static Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) { - fixed (InitState* __dsl_state = state) + fixed (sbyte* __dsl_name = name) { - SetInitialized(__dsl_state, (byte)initialized); + return (Scancode)GetScancodeFromName(__dsl_name); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => - Underlying.Value!.SetJoystickEventsEnabled(enabled); + public static Ptr GetScancodeName(Scancode scancode) => + Underlying.Value!.GetScancodeName(scancode); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetJoystickEventsEnabled( - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.SetJoystickEventsEnabled(enabled); + public static sbyte* GetScancodeNameRaw(Scancode scancode) => + Underlying.Value!.GetScancodeNameRaw(scancode); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickLED( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => Underlying.Value!.SetJoystickLED(joystick, red, green, blue); + public static uint GetSemaphoreValue(SemaphoreHandle sem) => + Underlying.Value!.GetSemaphoreValue(sem); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickLEDRaw( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => Underlying.Value!.SetJoystickLEDRaw(joystick, red, green, blue); + public static byte GetSensorData(SensorHandle sensor, float* data, int num_values) => + Underlying.Value!.GetSensorData(sensor, data, num_values); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickPlayerIndex( - JoystickHandle joystick, - int player_index - ) => Underlying.Value!.SetJoystickPlayerIndex(joystick, player_index); + public static MaybeBool GetSensorData( + SensorHandle sensor, + Ref data, + int num_values + ) + { + fixed (float* __dsl_data = data) + { + return (MaybeBool)(byte)GetSensorData(sensor, __dsl_data, num_values); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => - Underlying.Value!.SetJoystickPlayerIndexRaw(joystick, player_index); + public static SensorHandle GetSensorFromID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => Underlying.Value!.GetSensorFromID(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [return: NativeTypeName("SDL_SensorID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickVirtualAxis( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.SetJoystickVirtualAxis(joystick, axis, value); + public static uint GetSensorID(SensorHandle sensor) => + Underlying.Value!.GetSensorID(sensor); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickVirtualAxisRaw( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.SetJoystickVirtualAxisRaw(joystick, axis, value); + public static Ptr GetSensorName(SensorHandle sensor) => + Underlying.Value!.GetSensorName(sensor); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickVirtualBall( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => Underlying.Value!.SetJoystickVirtualBall(joystick, ball, xrel, yrel); + public static Ptr GetSensorNameForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => Underlying.Value!.GetSensorNameForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickVirtualBallRaw( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => Underlying.Value!.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); + public static sbyte* GetSensorNameForIDRaw( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => Underlying.Value!.GetSensorNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] byte down - ) => Underlying.Value!.SetJoystickVirtualButton(joystick, button, down); + public static sbyte* GetSensorNameRaw(SensorHandle sensor) => + Underlying.Value!.GetSensorNameRaw(sensor); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] MaybeBool down - ) => Underlying.Value!.SetJoystickVirtualButton(joystick, button, down); + public static int GetSensorNonPortableType(SensorHandle sensor) => + Underlying.Value!.GetSensorNonPortableType(sensor); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickVirtualHat( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => Underlying.Value!.SetJoystickVirtualHat(joystick, hat, value); + public static int GetSensorNonPortableTypeForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => Underlying.Value!.GetSensorNonPortableTypeForID(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickVirtualHatRaw( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => Underlying.Value!.SetJoystickVirtualHatRaw(joystick, hat, value); + public static uint GetSensorProperties(SensorHandle sensor) => + Underlying.Value!.GetSensorProperties(sensor); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [return: NativeTypeName("SDL_SensorID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] byte down, - float x, - float y, - float pressure - ) => - Underlying.Value!.SetJoystickVirtualTouchpad( - joystick, - touchpad, - finger, - down, - x, - y, - pressure - ); + public static uint* GetSensors(int* count) => Underlying.Value!.GetSensors(count); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_SensorID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] MaybeBool down, - float x, - float y, - float pressure - ) => - Underlying.Value!.SetJoystickVirtualTouchpad( - joystick, - touchpad, - finger, - down, - x, - y, - pressure - ); + public static Ptr GetSensors(Ref count) + { + fixed (int* __dsl_count = count) + { + return (uint*)GetSensors(__dsl_count); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - void* userdata - ) => Underlying.Value!.SetLogOutputFunction(callback, userdata); + public static SensorType GetSensorType(SensorHandle sensor) => + Underlying.Value!.GetSensorType(sensor); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - SetLogOutputFunction(callback, __dsl_userdata); - } - } + public static SensorType GetSensorTypeForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => Underlying.Value!.GetSensorTypeForID(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetLogPriorities(LogPriority priority) => - Underlying.Value!.SetLogPriorities(priority); + public static int GetSilenceValueForFormat(AudioFormat format) => + Underlying.Value!.GetSilenceValueForFormat(format); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetLogPriority(int category, LogPriority priority) => - Underlying.Value!.SetLogPriority(category, priority); + public static nuint GetSimdAlignment() => Underlying.Value!.GetSimdAlignment(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] sbyte* prefix - ) => Underlying.Value!.SetLogPriorityPrefix(priority, prefix); + public static byte GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("Uint64 *")] ulong* length + ) => Underlying.Value!.GetStorageFileSize(storage, path, length); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] Ref prefix + public static MaybeBool GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("Uint64 *")] Ref length ) { - fixed (sbyte* __dsl_prefix = prefix) + fixed (ulong* __dsl_length = length) + fixed (sbyte* __dsl_path = path) { - return (MaybeBool)(byte)SetLogPriorityPrefix(priority, __dsl_prefix); + return (MaybeBool)(byte)GetStorageFileSize(storage, __dsl_path, __dsl_length); } } - [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => - Underlying.Value!.SetModState(modstate); + public static byte GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + PathInfo* info + ) => Underlying.Value!.GetStoragePathInfo(storage, path, info); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetNumberProperty( + public static MaybeBool GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref info + ) + { + fixed (PathInfo* __dsl_info = info) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)GetStoragePathInfo(storage, __dsl_path, __dsl_info); + } + } + + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong GetStorageSpaceRemaining(StorageHandle storage) => + Underlying.Value!.GetStorageSpaceRemaining(storage); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* GetStringProperty( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long value - ) => Underlying.Value!.SetNumberProperty(props, name, value); + [NativeTypeName("const char *")] sbyte* default_value + ) => Underlying.Value!.GetStringProperty(props, name, default_value); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetNumberProperty( + public static Ptr GetStringProperty( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long value + [NativeTypeName("const char *")] Ref default_value ) { + fixed (sbyte* __dsl_default_value = default_value) fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)SetNumberProperty(props, __dsl_name, value); + return (sbyte*)GetStringProperty(props, __dsl_name, __dsl_default_value); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetPaletteColors( - Palette* palette, - [NativeTypeName("const SDL_Color *")] Color* colors, - int firstcolor, - int ncolors - ) => Underlying.Value!.SetPaletteColors(palette, colors, firstcolor, ncolors); + public static byte GetSurfaceAlphaMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* alpha + ) => Underlying.Value!.GetSurfaceAlphaMod(surface, alpha); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetPaletteColors( - Ref palette, - [NativeTypeName("const SDL_Color *")] Ref colors, - int firstcolor, - int ncolors + public static MaybeBool GetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref alpha ) { - fixed (Color* __dsl_colors = colors) - fixed (Palette* __dsl_palette = palette) + fixed (byte* __dsl_alpha = alpha) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte)SetPaletteColors(__dsl_palette, __dsl_colors, firstcolor, ncolors); + return (MaybeBool)(byte)GetSurfaceAlphaMod(__dsl_surface, __dsl_alpha); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value - ) => Underlying.Value!.SetPointerProperty(props, name, value); + public static byte GetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => Underlying.Value!.GetSurfaceBlendMode(surface, blendMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value + public static MaybeBool GetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode ) { - fixed (void* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (BlendMode* __dsl_blendMode = blendMode) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)SetPointerProperty(props, __dsl_name, __dsl_value); + return (MaybeBool)(byte)GetSurfaceBlendMode(__dsl_surface, __dsl_blendMode); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - void* userdata - ) => Underlying.Value!.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + public static byte GetSurfaceClipRect(Surface* surface, Rect* rect) => + Underlying.Value!.GetSurfaceClipRect(surface, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - Ref userdata - ) + public static MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) { - fixed (void* __dsl_userdata = userdata) - fixed (void* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte)SetPointerPropertyWithCleanup( - props, - __dsl_name, - __dsl_value, - cleanup, - __dsl_userdata - ); + return (MaybeBool)(byte)GetSurfaceClipRect(__dsl_surface, __dsl_rect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => - Underlying.Value!.SetPrimarySelectionText(text); + public static byte GetSurfaceColorKey( + Surface* surface, + [NativeTypeName("Uint32 *")] uint* key + ) => Underlying.Value!.GetSurfaceColorKey(surface, key); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetPrimarySelectionText( - [NativeTypeName("const char *")] Ref text + public static MaybeBool GetSurfaceColorKey( + Ref surface, + [NativeTypeName("Uint32 *")] Ref key ) { - fixed (sbyte* __dsl_text = text) + fixed (uint* __dsl_key = key) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)SetPrimarySelectionText(__dsl_text); + return (MaybeBool)(byte)GetSurfaceColorKey(__dsl_surface, __dsl_key); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => Underlying.Value!.SetRenderClipRect(renderer, rect); + public static byte GetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => Underlying.Value!.GetSurfaceColorMod(surface, r, g, b); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect + public static MaybeBool GetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b ) { - fixed (Rect* __dsl_rect = rect) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)SetRenderClipRect(renderer, __dsl_rect); + return (MaybeBool) + (byte)GetSurfaceColorMod(__dsl_surface, __dsl_r, __dsl_g, __dsl_b); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => - Underlying.Value!.SetRenderColorScale(renderer, scale); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => - Underlying.Value!.SetRenderColorScaleRaw(renderer, scale); + public static Colorspace GetSurfaceColorspace(Surface* surface) => + Underlying.Value!.GetSurfaceColorspace(surface); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => Underlying.Value!.SetRenderDrawBlendMode(renderer, blendMode); + public static Colorspace GetSurfaceColorspace(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Colorspace)GetSurfaceColorspace(__dsl_surface); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderDrawBlendModeRaw( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => Underlying.Value!.SetRenderDrawBlendModeRaw(renderer, blendMode); + public static Surface** GetSurfaceImages(Surface* surface, int* count) => + Underlying.Value!.GetSurfaceImages(surface, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => Underlying.Value!.SetRenderDrawColor(renderer, r, g, b, a); + public static Ptr2D GetSurfaceImages(Ref surface, Ref count) + { + fixed (int* __dsl_count = count) + fixed (Surface* __dsl_surface = surface) + { + return (Surface**)GetSurfaceImages(__dsl_surface, __dsl_count); + } + } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderDrawColorFloat( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => Underlying.Value!.SetRenderDrawColorFloat(renderer, r, g, b, a); + public static Palette* GetSurfacePalette(Surface* surface) => + Underlying.Value!.GetSurfacePalette(surface); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderDrawColorFloatRaw( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => Underlying.Value!.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); + public static Ptr GetSurfacePalette(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Palette*)GetSurfacePalette(__dsl_surface); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderDrawColorRaw( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => Underlying.Value!.SetRenderDrawColorRaw(renderer, r, g, b, a); + public static uint GetSurfaceProperties(Surface* surface) => + Underlying.Value!.GetSurfaceProperties(surface); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_PropertiesID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetRenderLogicalPresentation( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => Underlying.Value!.SetRenderLogicalPresentation(renderer, w, h, mode); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderLogicalPresentationRaw( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => Underlying.Value!.SetRenderLogicalPresentationRaw(renderer, w, h, mode); + public static uint GetSurfaceProperties(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (uint)GetSurfaceProperties(__dsl_surface); + } + } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderScale( - RendererHandle renderer, - float scaleX, - float scaleY - ) => Underlying.Value!.SetRenderScale(renderer, scaleX, scaleY); + public static int GetSystemRAM() => Underlying.Value!.GetSystemRAM(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => - Underlying.Value!.SetRenderScaleRaw(renderer, scaleX, scaleY); + public static SystemTheme GetSystemTheme() => Underlying.Value!.GetSystemTheme(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderTarget(RendererHandle renderer, Texture* texture) => - Underlying.Value!.SetRenderTarget(renderer, texture); + public static byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => + Underlying.Value!.GetTextInputArea(window, rect, cursor); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) + public static MaybeBool GetTextInputArea( + WindowHandle window, + Ref rect, + Ref cursor + ) { - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_cursor = cursor) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool)(byte)SetRenderTarget(renderer, __dsl_texture); + return (MaybeBool)(byte)GetTextInputArea(window, __dsl_rect, __dsl_cursor); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => Underlying.Value!.SetRenderViewport(renderer, rect); + public static byte GetTextureAlphaMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* alpha + ) => Underlying.Value!.GetTextureAlphaMod(texture, alpha); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect + public static MaybeBool GetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref alpha ) { - fixed (Rect* __dsl_rect = rect) + fixed (byte* __dsl_alpha = alpha) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetRenderViewport(renderer, __dsl_rect); + return (MaybeBool)(byte)GetTextureAlphaMod(__dsl_texture, __dsl_alpha); } } [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => - Underlying.Value!.SetRenderVSync(renderer, vsync); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => - Underlying.Value!.SetRenderVSyncRaw(renderer, vsync); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] sbyte* name - ) => Underlying.Value!.SetScancodeName(scancode, name); + public static byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => + Underlying.Value!.GetTextureAlphaModFloat(texture, alpha); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] Ref name + public static MaybeBool GetTextureAlphaModFloat( + Ref texture, + Ref alpha ) { - fixed (sbyte* __dsl_name = name) + fixed (float* __dsl_alpha = alpha) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetScancodeName(scancode, __dsl_name); + return (MaybeBool)(byte)GetTextureAlphaModFloat(__dsl_texture, __dsl_alpha); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => Underlying.Value!.SetStringProperty(props, name, value); + public static byte GetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => Underlying.Value!.GetTextureBlendMode(texture, blendMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value + public static MaybeBool GetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (BlendMode* __dsl_blendMode = blendMode) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetStringProperty(props, __dsl_name, __dsl_value); + return (MaybeBool)(byte)GetTextureBlendMode(__dsl_texture, __dsl_blendMode); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceAlphaMod( - Surface* surface, - [NativeTypeName("Uint8")] byte alpha - ) => Underlying.Value!.SetSurfaceAlphaMod(surface, alpha); + public static byte GetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => Underlying.Value!.GetTextureColorMod(texture, r, g, b); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8")] byte alpha + public static MaybeBool GetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b ) { - fixed (Surface* __dsl_surface = surface) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetSurfaceAlphaMod(__dsl_surface, alpha); + return (MaybeBool) + (byte)GetTextureColorMod(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => Underlying.Value!.SetSurfaceBlendMode(surface, blendMode); + public static byte GetTextureColorModFloat( + Texture* texture, + float* r, + float* g, + float* b + ) => Underlying.Value!.GetTextureColorModFloat(texture, r, g, b); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + public static MaybeBool GetTextureColorModFloat( + Ref texture, + Ref r, + Ref g, + Ref b ) { - fixed (Surface* __dsl_surface = surface) + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetSurfaceBlendMode(__dsl_surface, blendMode); + return (MaybeBool) + (byte)GetTextureColorModFloat(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceClipRect( - Surface* surface, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => Underlying.Value!.SetSurfaceClipRect(surface, rect); + public static uint GetTextureProperties(Texture* texture) => + Underlying.Value!.GetTextureProperties(texture); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_PropertiesID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceClipRect( - Ref surface, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) + public static uint GetTextureProperties(Ref texture) { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_surface = surface) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetSurfaceClipRect(__dsl_surface, __dsl_rect); + return (uint)GetTextureProperties(__dsl_texture); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceColorKey( - Surface* surface, - [NativeTypeName("bool")] byte enabled, - [NativeTypeName("Uint32")] uint key - ) => Underlying.Value!.SetSurfaceColorKey(surface, enabled, key); + public static byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => + Underlying.Value!.GetTextureScaleMode(texture, scaleMode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceColorKey( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled, - [NativeTypeName("Uint32")] uint key + public static MaybeBool GetTextureScaleMode( + Ref texture, + Ref scaleMode ) { - fixed (Surface* __dsl_surface = surface) + fixed (ScaleMode* __dsl_scaleMode = scaleMode) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetSurfaceColorKey(__dsl_surface, (byte)enabled, key); + return (MaybeBool)(byte)GetTextureScaleMode(__dsl_texture, __dsl_scaleMode); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => Underlying.Value!.SetSurfaceColorMod(surface, r, g, b); + public static byte GetTextureSize(Texture* texture, float* w, float* h) => + Underlying.Value!.GetTextureSize(texture, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b + public static MaybeBool GetTextureSize( + Ref texture, + Ref w, + Ref h ) { - fixed (Surface* __dsl_surface = surface) + fixed (float* __dsl_h = h) + fixed (float* __dsl_w = w) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)SetSurfaceColorMod(__dsl_surface, r, g, b); + return (MaybeBool)(byte)GetTextureSize(__dsl_texture, __dsl_w, __dsl_h); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => - Underlying.Value!.SetSurfaceColorspace(surface, colorspace); + public static ulong GetThreadID(ThreadHandle thread) => + Underlying.Value!.GetThreadID(thread); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceColorspace( - Ref surface, - Colorspace colorspace - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)SetSurfaceColorspace(__dsl_surface, colorspace); - } - } + public static Ptr GetThreadName(ThreadHandle thread) => + Underlying.Value!.GetThreadName(thread); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfacePalette(Surface* surface, Palette* palette) => - Underlying.Value!.SetSurfacePalette(surface, palette); + public static sbyte* GetThreadNameRaw(ThreadHandle thread) => + Underlying.Value!.GetThreadNameRaw(thread); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfacePalette(Ref surface, Ref palette) - { - fixed (Palette* __dsl_palette = palette) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)SetSurfacePalette(__dsl_surface, __dsl_palette); - } - } + public static ulong GetTicks() => Underlying.Value!.GetTicks(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => - Underlying.Value!.SetSurfaceRLE(surface, enabled); + public static ulong GetTicksNS() => Underlying.Value!.GetTicksNS(); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => + Underlying.Value!.GetTLS(id); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetSurfaceRLE( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled - ) + public static Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) { - fixed (Surface* __dsl_surface = surface) + fixed (AtomicInt* __dsl_id = id) { - return (MaybeBool)(byte)SetSurfaceRLE(__dsl_surface, (byte)enabled); + return (void*)GetTLS(__dsl_id); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextInputArea( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int cursor - ) => Underlying.Value!.SetTextInputArea(window, rect, cursor); - - [return: NativeTypeName("bool")] + public static Ptr GetTouchDeviceName( + [NativeTypeName("SDL_TouchID")] ulong touchID + ) => Underlying.Value!.GetTouchDeviceName(touchID); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => + Underlying.Value!.GetTouchDeviceNameRaw(touchID); + + [return: NativeTypeName("SDL_TouchID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong* GetTouchDevices(int* count) => + Underlying.Value!.GetTouchDevices(count); + + [return: NativeTypeName("SDL_TouchID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextInputArea( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect, - int cursor - ) + public static Ptr GetTouchDevices(Ref count) { - fixed (Rect* __dsl_rect = rect) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)SetTextInputArea(window, __dsl_rect, cursor); + return (ulong*)GetTouchDevices(__dsl_count); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureAlphaMod( - Texture* texture, - [NativeTypeName("Uint8")] byte alpha - ) => Underlying.Value!.SetTextureAlphaMod(texture, alpha); + public static TouchDeviceType GetTouchDeviceType( + [NativeTypeName("SDL_TouchID")] ulong touchID + ) => Underlying.Value!.GetTouchDeviceType(touchID); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Finger** GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + int* count + ) => Underlying.Value!.GetTouchFingers(touchID, count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8")] byte alpha + public static Ptr2D GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + Ref count ) { - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)SetTextureAlphaMod(__dsl_texture, alpha); + return (Finger**)GetTouchFingers(touchID, __dsl_count); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureAlphaModFloat(Texture* texture, float alpha) => - Underlying.Value!.SetTextureAlphaModFloat(texture, alpha); + public static Ptr GetUserFolder(Folder folder) => + Underlying.Value!.GetUserFolder(folder); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) - { - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool)(byte)SetTextureAlphaModFloat(__dsl_texture, alpha); - } - } + public static sbyte* GetUserFolderRaw(Folder folder) => + Underlying.Value!.GetUserFolderRaw(folder); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => Underlying.Value!.SetTextureBlendMode(texture, blendMode); + public static int GetVersion() => Underlying.Value!.GetVersion(); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) - { - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool)(byte)SetTextureBlendMode(__dsl_texture, blendMode); - } - } + public static Ptr GetVideoDriver(int index) => + Underlying.Value!.GetVideoDriver(index); + + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* GetVideoDriverRaw(int index) => + Underlying.Value!.GetVideoDriverRaw(index); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => Underlying.Value!.SetTextureColorMod(texture, r, g, b); + public static byte GetWindowAspectRatio( + WindowHandle window, + float* min_aspect, + float* max_aspect + ) => Underlying.Value!.GetWindowAspectRatio(window, min_aspect, max_aspect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b + public static MaybeBool GetWindowAspectRatio( + WindowHandle window, + Ref min_aspect, + Ref max_aspect ) { - fixed (Texture* __dsl_texture = texture) + fixed (float* __dsl_max_aspect = max_aspect) + fixed (float* __dsl_min_aspect = min_aspect) { - return (MaybeBool)(byte)SetTextureColorMod(__dsl_texture, r, g, b); + return (MaybeBool) + (byte)GetWindowAspectRatio(window, __dsl_min_aspect, __dsl_max_aspect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => - Underlying.Value!.SetTextureColorModFloat(texture, r, g, b); + public static byte GetWindowBordersSize( + WindowHandle window, + int* top, + int* left, + int* bottom, + int* right + ) => Underlying.Value!.GetWindowBordersSize(window, top, left, bottom, right); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureColorModFloat( - Ref texture, - float r, - float g, - float b + public static MaybeBool GetWindowBordersSize( + WindowHandle window, + Ref top, + Ref left, + Ref bottom, + Ref right ) { - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_right = right) + fixed (int* __dsl_bottom = bottom) + fixed (int* __dsl_left = left) + fixed (int* __dsl_top = top) { - return (MaybeBool)(byte)SetTextureColorModFloat(__dsl_texture, r, g, b); + return (MaybeBool) + (byte)GetWindowBordersSize( + window, + __dsl_top, + __dsl_left, + __dsl_bottom, + __dsl_right + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => - Underlying.Value!.SetTextureScaleMode(texture, scaleMode); + public static float GetWindowDisplayScale(WindowHandle window) => + Underlying.Value!.GetWindowDisplayScale(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [return: NativeTypeName("SDL_WindowFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) - { - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool)(byte)SetTextureScaleMode(__dsl_texture, scaleMode); - } - } + public static ulong GetWindowFlags(WindowHandle window) => + Underlying.Value!.GetWindowFlags(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetTLS( - [NativeTypeName("SDL_TLSID *")] AtomicInt* id, - [NativeTypeName("const void *")] void* value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor - ) => Underlying.Value!.SetTLS(id, value, destructor); + public static WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Event* @event + ) => Underlying.Value!.GetWindowFromEvent(@event); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetTLS( - [NativeTypeName("SDL_TLSID *")] Ref id, - [NativeTypeName("const void *")] Ref value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + public static WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Ref @event ) { - fixed (void* __dsl_value = value) - fixed (AtomicInt* __dsl_id = id) + fixed (Event* __dsl_event = @event) { - return (MaybeBool)(byte)SetTLS(__dsl_id, __dsl_value, destructor); + return (WindowHandle)GetWindowFromEvent(__dsl_event); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static byte SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] byte on_top - ) => Underlying.Value!.SetWindowAlwaysOnTop(window, on_top); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool on_top - ) => Underlying.Value!.SetWindowAlwaysOnTop(window, on_top); + public static WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => + Underlying.Value!.GetWindowFromID(id); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowAspectRatio( - WindowHandle window, - float min_aspect, - float max_aspect - ) => Underlying.Value!.SetWindowAspectRatio(window, min_aspect, max_aspect); + public static Ptr GetWindowFullscreenMode(WindowHandle window) => + Underlying.Value!.GetWindowFullscreenMode(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowAspectRatioRaw( - WindowHandle window, - float min_aspect, - float max_aspect - ) => Underlying.Value!.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); + public static DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => + Underlying.Value!.GetWindowFullscreenModeRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowBordered( + public static void* GetWindowICCProfile( WindowHandle window, - [NativeTypeName("bool")] byte bordered - ) => Underlying.Value!.SetWindowBordered(window, bordered); + [NativeTypeName("size_t *")] nuint* size + ) => Underlying.Value!.GetWindowICCProfile(window, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowBordered( + public static Ptr GetWindowICCProfile( WindowHandle window, - [NativeTypeName("bool")] MaybeBool bordered - ) => Underlying.Value!.SetWindowBordered(window, bordered); + [NativeTypeName("size_t *")] Ref size + ) + { + fixed (nuint* __dsl_size = size) + { + return (void*)GetWindowICCProfile(window, __dsl_size); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [return: NativeTypeName("SDL_WindowID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] byte focusable - ) => Underlying.Value!.SetWindowFocusable(window, focusable); + public static uint GetWindowID(WindowHandle window) => + Underlying.Value!.GetWindowID(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool focusable - ) => Underlying.Value!.SetWindowFocusable(window, focusable); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] byte fullscreen - ) => Underlying.Value!.SetWindowFullscreen(window, fullscreen); + public static MaybeBool GetWindowKeyboardGrab(WindowHandle window) => + Underlying.Value!.GetWindowKeyboardGrab(window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool fullscreen - ) => Underlying.Value!.SetWindowFullscreen(window, fullscreen); + public static byte GetWindowKeyboardGrabRaw(WindowHandle window) => + Underlying.Value!.GetWindowKeyboardGrabRaw(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode - ) => Underlying.Value!.SetWindowFullscreenMode(window, mode); + public static byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => + Underlying.Value!.GetWindowMaximumSize(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowFullscreenMode( + public static MaybeBool GetWindowMaximumSize( WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] Ref mode + Ref w, + Ref h ) { - fixed (DisplayMode* __dsl_mode = mode) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (MaybeBool)(byte)SetWindowFullscreenMode(window, __dsl_mode); + return (MaybeBool)(byte)GetWindowMaximumSize(window, __dsl_w, __dsl_h); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - void* callback_data - ) => Underlying.Value!.SetWindowHitTest(window, callback, callback_data); + public static byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => + Underlying.Value!.GetWindowMinimumSize(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowHitTest( + public static MaybeBool GetWindowMinimumSize( WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - Ref callback_data + Ref w, + Ref h ) { - fixed (void* __dsl_callback_data = callback_data) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (MaybeBool) - (byte)SetWindowHitTest(window, callback, __dsl_callback_data); + return (MaybeBool)(byte)GetWindowMinimumSize(window, __dsl_w, __dsl_h); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowIcon(WindowHandle window, Surface* icon) => - Underlying.Value!.SetWindowIcon(window, icon); + public static MaybeBool GetWindowMouseGrab(WindowHandle window) => + Underlying.Value!.GetWindowMouseGrab(window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowIcon(WindowHandle window, Ref icon) - { - fixed (Surface* __dsl_icon = icon) - { - return (MaybeBool)(byte)SetWindowIcon(window, __dsl_icon); - } - } + public static byte GetWindowMouseGrabRaw(WindowHandle window) => + Underlying.Value!.GetWindowMouseGrabRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [return: NativeTypeName("const SDL_Rect *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowKeyboardGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => Underlying.Value!.SetWindowKeyboardGrab(window, grabbed); + public static Ptr GetWindowMouseRect(WindowHandle window) => + Underlying.Value!.GetWindowMouseRect(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [return: NativeTypeName("const SDL_Rect *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowKeyboardGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => Underlying.Value!.SetWindowKeyboardGrab(window, grabbed); + public static Rect* GetWindowMouseRectRaw(WindowHandle window) => + Underlying.Value!.GetWindowMouseRectRaw(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowMaximumSize( - WindowHandle window, - int max_w, - int max_h - ) => Underlying.Value!.SetWindowMaximumSize(window, max_w, max_h); + public static float GetWindowOpacity(WindowHandle window) => + Underlying.Value!.GetWindowOpacity(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => - Underlying.Value!.SetWindowMaximumSizeRaw(window, max_w, max_h); + public static WindowHandle GetWindowParent(WindowHandle window) => + Underlying.Value!.GetWindowParent(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowMinimumSize( - WindowHandle window, - int min_w, - int min_h - ) => Underlying.Value!.SetWindowMinimumSize(window, min_w, min_h); + public static float GetWindowPixelDensity(WindowHandle window) => + Underlying.Value!.GetWindowPixelDensity(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => - Underlying.Value!.SetWindowMinimumSizeRaw(window, min_w, min_h); + public static PixelFormat GetWindowPixelFormat(WindowHandle window) => + Underlying.Value!.GetWindowPixelFormat(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowModal( - WindowHandle window, - [NativeTypeName("bool")] byte modal - ) => Underlying.Value!.SetWindowModal(window, modal); + public static byte GetWindowPosition(WindowHandle window, int* x, int* y) => + Underlying.Value!.GetWindowPosition(window, x, y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowModal( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool modal - ) => Underlying.Value!.SetWindowModal(window, modal); + public static MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) + { + fixed (int* __dsl_y = y) + fixed (int* __dsl_x = x) + { + return (MaybeBool)(byte)GetWindowPosition(window, __dsl_x, __dsl_y); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => Underlying.Value!.SetWindowMouseGrab(window, grabbed); + public static uint GetWindowProperties(WindowHandle window) => + Underlying.Value!.GetWindowProperties(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => Underlying.Value!.SetWindowMouseGrab(window, grabbed); + public static MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => + Underlying.Value!.GetWindowRelativeMouseMode(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => Underlying.Value!.SetWindowMouseRect(window, rect); + public static byte GetWindowRelativeMouseModeRaw(WindowHandle window) => + Underlying.Value!.GetWindowRelativeMouseModeRaw(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)SetWindowMouseRect(window, __dsl_rect); - } - } + public static WindowHandle* GetWindows(int* count) => Underlying.Value!.GetWindows(count); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => - Underlying.Value!.SetWindowOpacity(window, opacity); + public static Ptr GetWindows(Ref count) + { + fixed (int* __dsl_count = count) + { + return (WindowHandle*)GetWindows(__dsl_count); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowOpacityRaw(WindowHandle window, float opacity) => - Underlying.Value!.SetWindowOpacityRaw(window, opacity); + public static byte GetWindowSafeArea(WindowHandle window, Rect* rect) => + Underlying.Value!.GetWindowSafeArea(window, rect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => - Underlying.Value!.SetWindowParent(window, parent); + public static MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)GetWindowSafeArea(window, __dsl_rect); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => - Underlying.Value!.SetWindowParentRaw(window, parent); + public static byte GetWindowSize(WindowHandle window, int* w, int* h) => + Underlying.Value!.GetWindowSize(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => - Underlying.Value!.SetWindowPosition(window, x, y); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowPositionRaw(WindowHandle window, int x, int y) => - Underlying.Value!.SetWindowPositionRaw(window, x, y); + public static MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) + { + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) + { + return (MaybeBool)(byte)GetWindowSize(window, __dsl_w, __dsl_h); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] byte enabled - ) => Underlying.Value!.SetWindowRelativeMouseMode(window, enabled); + public static byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => + Underlying.Value!.GetWindowSizeInPixels(window, w, h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowRelativeMouseMode( + public static MaybeBool GetWindowSizeInPixels( WindowHandle window, - [NativeTypeName("bool")] MaybeBool enabled - ) => Underlying.Value!.SetWindowRelativeMouseMode(window, enabled); + Ref w, + Ref h + ) + { + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) + { + return (MaybeBool)(byte)GetWindowSizeInPixels(window, __dsl_w, __dsl_h); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] byte resizable - ) => Underlying.Value!.SetWindowResizable(window, resizable); + public static Ptr GetWindowSurface(WindowHandle window) => + Underlying.Value!.GetWindowSurface(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool resizable - ) => Underlying.Value!.SetWindowResizable(window, resizable); + public static Surface* GetWindowSurfaceRaw(WindowHandle window) => + Underlying.Value!.GetWindowSurfaceRaw(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowShape(WindowHandle window, Surface* shape) => - Underlying.Value!.SetWindowShape(window, shape); + public static byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => + Underlying.Value!.GetWindowSurfaceVSync(window, vsync); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowShape(WindowHandle window, Ref shape) + public static MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) { - fixed (Surface* __dsl_shape = shape) + fixed (int* __dsl_vsync = vsync) { - return (MaybeBool)(byte)SetWindowShape(window, __dsl_shape); + return (MaybeBool)(byte)GetWindowSurfaceVSync(window, __dsl_vsync); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool SetWindowSize(WindowHandle window, int w, int h) => - Underlying.Value!.SetWindowSize(window, w, h); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowSizeRaw(WindowHandle window, int w, int h) => - Underlying.Value!.SetWindowSizeRaw(window, w, h); + public static Ptr GetWindowTitle(WindowHandle window) => + Underlying.Value!.GetWindowTitle(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => - Underlying.Value!.SetWindowSurfaceVSync(window, vsync); + public static sbyte* GetWindowTitleRaw(WindowHandle window) => + Underlying.Value!.GetWindowTitleRaw(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => - Underlying.Value!.SetWindowSurfaceVSyncRaw(window, vsync); + public static GLContextStateHandle GLCreateContext(WindowHandle window) => + Underlying.Value!.GLCreateContext(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* title - ) => Underlying.Value!.SetWindowTitle(window, title); + public static MaybeBool GLDestroyContext( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => Underlying.Value!.GLDestroyContext(context); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] Ref title - ) - { - fixed (sbyte* __dsl_title = title) - { - return (MaybeBool)(byte)SetWindowTitle(window, __dsl_title); - } - } + public static byte GLDestroyContextRaw( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => Underlying.Value!.GLDestroyContextRaw(context); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShouldInit(InitState* state) => Underlying.Value!.ShouldInit(state); + public static byte GLExtensionSupported( + [NativeTypeName("const char *")] sbyte* extension + ) => Underlying.Value!.GLExtensionSupported(extension); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShouldInit(Ref state) + public static MaybeBool GLExtensionSupported( + [NativeTypeName("const char *")] Ref extension + ) { - fixed (InitState* __dsl_state = state) + fixed (sbyte* __dsl_extension = extension) { - return (MaybeBool)(byte)ShouldInit(__dsl_state); + return (MaybeBool)(byte)GLExtensionSupported(__dsl_extension); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShouldQuit(InitState* state) => Underlying.Value!.ShouldQuit(state); + public static byte GLGetAttribute(GLAttr attr, int* value) => + Underlying.Value!.GLGetAttribute(attr, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShouldQuit(Ref state) + public static MaybeBool GLGetAttribute(GLAttr attr, Ref value) { - fixed (InitState* __dsl_state = state) + fixed (int* __dsl_value = value) { - return (MaybeBool)(byte)ShouldQuit(__dsl_state); + return (MaybeBool)(byte)GLGetAttribute(attr, __dsl_value); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShowCursor() => Underlying.Value!.ShowCursor(); + public static GLContextStateHandle GLGetCurrentContext() => + Underlying.Value!.GLGetCurrentContext(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShowCursorRaw() => Underlying.Value!.ShowCursorRaw(); + public static WindowHandle GLGetCurrentWindow() => Underlying.Value!.GLGetCurrentWindow(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, - int* buttonid - ) => Underlying.Value!.ShowMessageBox(messageboxdata, buttonid); + public static FunctionPointer GLGetProcAddress( + [NativeTypeName("const char *")] sbyte* proc + ) => Underlying.Value!.GLGetProcAddress(proc); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, - Ref buttonid + public static FunctionPointer GLGetProcAddress( + [NativeTypeName("const char *")] Ref proc ) { - fixed (int* __dsl_buttonid = buttonid) - fixed (MessageBoxData* __dsl_messageboxdata = messageboxdata) + fixed (sbyte* __dsl_proc = proc) { - return (MaybeBool)(byte)ShowMessageBox(__dsl_messageboxdata, __dsl_buttonid); + return (FunctionPointer)GLGetProcAddress(__dsl_proc); } } - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => - Underlying.Value!.ShowOpenFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location, - allow_many - ); + public static byte GLGetSwapInterval(int* interval) => + Underlying.Value!.GLGetSwapInterval(interval); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many - ) + public static MaybeBool GLGetSwapInterval(Ref interval) { - fixed (sbyte* __dsl_default_location = default_location) - fixed (DialogFileFilter* __dsl_filters = filters) - fixed (void* __dsl_userdata = userdata) + fixed (int* __dsl_interval = interval) { - ShowOpenFileDialog( - callback, - __dsl_userdata, - window, - __dsl_filters, - nfilters, - __dsl_default_location, - (byte)allow_many - ); + return (MaybeBool)(byte)GLGetSwapInterval(__dsl_interval); } } - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => - Underlying.Value!.ShowOpenFolderDialog( - callback, - userdata, - window, - default_location, - allow_many - ); + public static byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.GLLoadLibrary(path); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many + public static MaybeBool GLLoadLibrary( + [NativeTypeName("const char *")] Ref path ) { - fixed (sbyte* __dsl_default_location = default_location) - fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_path = path) { - ShowOpenFolderDialog( - callback, - __dsl_userdata, - window, - __dsl_default_location, - (byte)allow_many - ); + return (MaybeBool)(byte)GLLoadLibrary(__dsl_path); } } - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, + public static MaybeBool GLMakeCurrent( WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location - ) => - Underlying.Value!.ShowSaveFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location - ); + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => Underlying.Value!.GLMakeCurrent(window, context); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, + public static byte GLMakeCurrentRaw( WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location - ) - { - fixed (sbyte* __dsl_default_location = default_location) - fixed (DialogFileFilter* __dsl_filters = filters) - fixed (void* __dsl_userdata = userdata) - { - ShowSaveFileDialog( - callback, - __dsl_userdata, - window, - __dsl_filters, - nfilters, - __dsl_default_location - ); - } - } + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => Underlying.Value!.GLMakeCurrentRaw(window, context); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] sbyte* title, - [NativeTypeName("const char *")] sbyte* message, - WindowHandle window - ) => Underlying.Value!.ShowSimpleMessageBox(flags, title, message, window); + public static void GLResetAttributes() => Underlying.Value!.GLResetAttributes(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] Ref title, - [NativeTypeName("const char *")] Ref message, - WindowHandle window - ) - { - fixed (sbyte* __dsl_message = message) - fixed (sbyte* __dsl_title = title) - { - return (MaybeBool) - (byte)ShowSimpleMessageBox(flags, __dsl_title, __dsl_message, window); - } - } + public static MaybeBool GLSetAttribute(GLAttr attr, int value) => + Underlying.Value!.GLSetAttribute(attr, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShowWindow(WindowHandle window) => - Underlying.Value!.ShowWindow(window); + public static byte GLSetAttributeRaw(GLAttr attr, int value) => + Underlying.Value!.GLSetAttributeRaw(attr, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShowWindowRaw(WindowHandle window) => - Underlying.Value!.ShowWindowRaw(window); + public static MaybeBool GLSetSwapInterval(int interval) => + Underlying.Value!.GLSetSwapInterval(interval); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => - Underlying.Value!.ShowWindowSystemMenu(window, x, y); + public static byte GLSetSwapIntervalRaw(int interval) => + Underlying.Value!.GLSetSwapIntervalRaw(interval); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => - Underlying.Value!.ShowWindowSystemMenuRaw(window, x, y); + public static MaybeBool GLSwapWindow(WindowHandle window) => + Underlying.Value!.GLSwapWindow(window); - [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SignalCondition(ConditionHandle cond) => - Underlying.Value!.SignalCondition(cond); + public static byte GLSwapWindowRaw(WindowHandle window) => + Underlying.Value!.GLSwapWindowRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void SignalSemaphore(SemaphoreHandle sem) => - Underlying.Value!.SignalSemaphore(sem); + public static void GLUnloadLibrary() => Underlying.Value!.GLUnloadLibrary(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StartTextInput(WindowHandle window) => - Underlying.Value!.StartTextInput(window); + public static sbyte** GlobDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => Underlying.Value!.GlobDirectory(path, pattern, flags, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StartTextInputRaw(WindowHandle window) => - Underlying.Value!.StartTextInputRaw(window); + public static Ptr2D GlobDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) + { + fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_pattern = pattern) + fixed (sbyte* __dsl_path = path) + { + return (sbyte**)GlobDirectory(__dsl_path, __dsl_pattern, flags, __dsl_count); + } + } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StartTextInputWithProperties( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.StartTextInputWithProperties(window, props); + public static sbyte** GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => Underlying.Value!.GlobStorageDirectory(storage, path, pattern, flags, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StartTextInputWithPropertiesRaw( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => Underlying.Value!.StartTextInputWithPropertiesRaw(window, props); + public static Ptr2D GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) + { + fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_pattern = pattern) + fixed (sbyte* __dsl_path = path) + { + return (sbyte**)GlobStorageDirectory( + storage, + __dsl_path, + __dsl_pattern, + flags, + __dsl_count + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => - Underlying.Value!.StopHapticEffect(haptic, effect); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StopHapticEffectRaw(HapticHandle haptic, int effect) => - Underlying.Value!.StopHapticEffectRaw(haptic, effect); + public static MaybeBool GPUSupportsProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.GPUSupportsProperties(props); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StopHapticEffects(HapticHandle haptic) => - Underlying.Value!.StopHapticEffects(haptic); + public static byte GPUSupportsPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.GPUSupportsPropertiesRaw(props); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StopHapticEffectsRaw(HapticHandle haptic) => - Underlying.Value!.StopHapticEffectsRaw(haptic); + public static byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.GPUSupportsShaderFormats(format_flags, name); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StopHapticRumble(HapticHandle haptic) => - Underlying.Value!.StopHapticRumble(haptic); + public static MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)GPUSupportsShaderFormats(format_flags, __dsl_name); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StopHapticRumbleRaw(HapticHandle haptic) => - Underlying.Value!.StopHapticRumbleRaw(haptic); + public static uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format) => + Underlying.Value!.GPUTextureFormatTexelBlockSize(format); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StopTextInput(WindowHandle window) => - Underlying.Value!.StopTextInput(window); + public static MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => Underlying.Value!.GPUTextureSupportsFormat(device, format, type, usage); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StopTextInputRaw(WindowHandle window) => - Underlying.Value!.StopTextInputRaw(window); + public static byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => Underlying.Value!.GPUTextureSupportsFormatRaw(device, format, type, usage); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool StorageReady(StorageHandle storage) => - Underlying.Value!.StorageReady(storage); + public static MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => Underlying.Value!.GPUTextureSupportsSampleCount(device, format, sample_count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte StorageReadyRaw(StorageHandle storage) => - Underlying.Value!.StorageReadyRaw(storage); + public static byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => Underlying.Value!.GPUTextureSupportsSampleCountRaw(device, format, sample_count); - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => - Underlying.Value!.StringToGuid(pchGUID); + public static void GuidToString( + Guid guid, + [NativeTypeName("char *")] sbyte* pszGUID, + int cbGUID + ) => Underlying.Value!.GuidToString(guid, pszGUID, cbGUID); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) + public static void GuidToString( + Guid guid, + [NativeTypeName("char *")] Ref pszGUID, + int cbGUID + ) { - fixed (sbyte* __dsl_pchGUID = pchGUID) + fixed (sbyte* __dsl_pszGUID = pszGUID) { - return (Guid)StringToGuid(__dsl_pchGUID); + GuidToString(guid, __dsl_pszGUID, cbGUID); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SurfaceHasAlternateImages(Surface* surface) => - Underlying.Value!.SurfaceHasAlternateImages(surface); + public static byte HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => Underlying.Value!.HapticEffectSupported(haptic, effect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasAlternateImages(Ref surface) + public static MaybeBool HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) { - fixed (Surface* __dsl_surface = surface) + fixed (HapticEffect* __dsl_effect = effect) { - return (MaybeBool)(byte)SurfaceHasAlternateImages(__dsl_surface); + return (MaybeBool)(byte)HapticEffectSupported(haptic, __dsl_effect); } } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SurfaceHasColorKey(Surface* surface) => - Underlying.Value!.SurfaceHasColorKey(surface); + public static MaybeBool HapticRumbleSupported(HapticHandle haptic) => + Underlying.Value!.HapticRumbleSupported(haptic); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte HapticRumbleSupportedRaw(HapticHandle haptic) => + Underlying.Value!.HapticRumbleSupportedRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasColorKey(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)SurfaceHasColorKey(__dsl_surface); - } - } + public static MaybeBool HasAltiVec() => Underlying.Value!.HasAltiVec(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SurfaceHasRLE(Surface* surface) => - Underlying.Value!.SurfaceHasRLE(surface); + public static byte HasAltiVecRaw() => Underlying.Value!.HasAltiVecRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SurfaceHasRLE(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)SurfaceHasRLE(__dsl_surface); - } - } + public static MaybeBool HasArmsimd() => Underlying.Value!.HasArmsimd(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte HasArmsimdRaw() => Underlying.Value!.HasArmsimdRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool SyncWindow(WindowHandle window) => - Underlying.Value!.SyncWindow(window); + public static MaybeBool HasAVX() => Underlying.Value!.HasAVX(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte SyncWindowRaw(WindowHandle window) => - Underlying.Value!.SyncWindowRaw(window); + public static MaybeBool HasAVX2() => Underlying.Value!.HasAVX2(); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long TellIO(IOStreamHandle context) => Underlying.Value!.TellIO(context); + public static byte HasAVX2Raw() => Underlying.Value!.HasAVX2Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TextInputActive(WindowHandle window) => - Underlying.Value!.TextInputActive(window); + public static MaybeBool HasAVX512F() => Underlying.Value!.HasAVX512F(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TextInputActiveRaw(WindowHandle window) => - Underlying.Value!.TextInputActiveRaw(window); + public static byte HasAVX512FRaw() => Underlying.Value!.HasAVX512FRaw(); - [return: NativeTypeName("SDL_Time")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static long TimeFromWindows( - [NativeTypeName("Uint32")] uint dwLowDateTime, - [NativeTypeName("Uint32")] uint dwHighDateTime - ) => Underlying.Value!.TimeFromWindows(dwLowDateTime, dwHighDateTime); + public static byte HasAVXRaw() => Underlying.Value!.HasAVXRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - DateTime* dt, - [NativeTypeName("bool")] byte localTime - ) => Underlying.Value!.TimeToDateTime(ticks, dt, localTime); + public static byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => + Underlying.Value!.HasClipboardData(mime_type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TimeToDateTime( - [NativeTypeName("SDL_Time")] long ticks, - Ref dt, - [NativeTypeName("bool")] MaybeBool localTime + public static MaybeBool HasClipboardData( + [NativeTypeName("const char *")] Ref mime_type ) { - fixed (DateTime* __dsl_dt = dt) + fixed (sbyte* __dsl_mime_type = mime_type) { - return (MaybeBool)(byte)TimeToDateTime(ticks, __dsl_dt, (byte)localTime); + return (MaybeBool)(byte)HasClipboardData(__dsl_mime_type); } } - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] uint* dwLowDateTime, - [NativeTypeName("Uint32 *")] uint* dwHighDateTime - ) => Underlying.Value!.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); + public static MaybeBool HasClipboardText() => Underlying.Value!.HasClipboardText(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void TimeToWindows( - [NativeTypeName("SDL_Time")] long ticks, - [NativeTypeName("Uint32 *")] Ref dwLowDateTime, - [NativeTypeName("Uint32 *")] Ref dwHighDateTime - ) - { - fixed (uint* __dsl_dwHighDateTime = dwHighDateTime) - fixed (uint* __dsl_dwLowDateTime = dwLowDateTime) - { - TimeToWindows(ticks, __dsl_dwLowDateTime, __dsl_dwHighDateTime); - } - } + public static byte HasClipboardTextRaw() => Underlying.Value!.HasClipboardTextRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryLockMutex(MutexHandle mutex) => - Underlying.Value!.TryLockMutex(mutex); + public static MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => + Underlying.Value!.HasEvent(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TryLockMutexRaw(MutexHandle mutex) => - Underlying.Value!.TryLockMutexRaw(mutex); + public static byte HasEventRaw([NativeTypeName("Uint32")] uint type) => + Underlying.Value!.HasEventRaw(type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => - Underlying.Value!.TryLockRWLockForReading(rwlock); + public static MaybeBool HasEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => Underlying.Value!.HasEvents(minType, maxType); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TryLockRWLockForReadingRaw(RWLockHandle rwlock) => - Underlying.Value!.TryLockRWLockForReadingRaw(rwlock); + public static byte HasEventsRaw( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => Underlying.Value!.HasEventsRaw(minType, maxType); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => - Underlying.Value!.TryLockRWLockForWriting(rwlock); + public static MaybeBool HasGamepad() => Underlying.Value!.HasGamepad(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TryLockRWLockForWritingRaw(RWLockHandle rwlock) => - Underlying.Value!.TryLockRWLockForWritingRaw(rwlock); + public static byte HasGamepadRaw() => Underlying.Value!.HasGamepadRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - Underlying.Value!.TryLockSpinlock(@lock); + public static MaybeBool HasJoystick() => Underlying.Value!.HasJoystick(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte HasJoystickRaw() => Underlying.Value!.HasJoystickRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryLockSpinlock( - [NativeTypeName("SDL_SpinLock *")] Ref @lock - ) - { - fixed (int* __dsl_lock = @lock) - { - return (MaybeBool)(byte)TryLockSpinlock(__dsl_lock); - } - } + public static MaybeBool HasKeyboard() => Underlying.Value!.HasKeyboard(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte HasKeyboardRaw() => Underlying.Value!.HasKeyboardRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => - Underlying.Value!.TryWaitSemaphore(sem); + public static MaybeBool HasLasx() => Underlying.Value!.HasLasx(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => - Underlying.Value!.TryWaitSemaphoreRaw(sem); + public static byte HasLasxRaw() => Underlying.Value!.HasLasxRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnbindAudioStream(AudioStreamHandle stream) => - Underlying.Value!.UnbindAudioStream(stream); + public static MaybeBool HasLSX() => Underlying.Value!.HasLSX(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams) => - Underlying.Value!.UnbindAudioStreams(streams, num_streams); + public static byte HasLSXRaw() => Underlying.Value!.HasLSXRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnbindAudioStreams(Ref streams, int num_streams) - { - fixed (AudioStreamHandle* __dsl_streams = streams) - { - UnbindAudioStreams(__dsl_streams, num_streams); - } - } + public static MaybeBool HasMMX() => Underlying.Value!.HasMMX(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnloadObject")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnloadObject(SharedObjectHandle handle) => - Underlying.Value!.UnloadObject(handle); + public static byte HasMMXRaw() => Underlying.Value!.HasMMXRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UnlockAudioStream(AudioStreamHandle stream) => - Underlying.Value!.UnlockAudioStream(stream); + public static MaybeBool HasMouse() => Underlying.Value!.HasMouse(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UnlockAudioStreamRaw(AudioStreamHandle stream) => - Underlying.Value!.UnlockAudioStreamRaw(stream); + public static byte HasMouseRaw() => Underlying.Value!.HasMouseRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockJoysticks")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockJoysticks() => Underlying.Value!.UnlockJoysticks(); + public static MaybeBool HasNeon() => Underlying.Value!.HasNeon(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockMutex")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockMutex(MutexHandle mutex) => Underlying.Value!.UnlockMutex(mutex); + public static byte HasNeonRaw() => Underlying.Value!.HasNeonRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - Underlying.Value!.UnlockProperties(props); + public static MaybeBool HasPrimarySelectionText() => + Underlying.Value!.HasPrimarySelectionText(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockRWLock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockRWLock(RWLockHandle rwlock) => - Underlying.Value!.UnlockRWLock(rwlock); + public static byte HasPrimarySelectionTextRaw() => + Underlying.Value!.HasPrimarySelectionTextRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - Underlying.Value!.UnlockSpinlock(@lock); + public static byte HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.HasProperty(props, name); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + public static MaybeBool HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) { - fixed (int* __dsl_lock = @lock) + fixed (sbyte* __dsl_name = name) { - UnlockSpinlock(__dsl_lock); + return (MaybeBool)(byte)HasProperty(props, __dsl_name); } } - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSurface(Surface* surface) => - Underlying.Value!.UnlockSurface(surface); + public static byte HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B + ) => Underlying.Value!.HasRectIntersection(A, B); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockSurface(Ref surface) + public static MaybeBool HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B + ) { - fixed (Surface* __dsl_surface = surface) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) { - UnlockSurface(__dsl_surface); + return (MaybeBool)(byte)HasRectIntersection(__dsl_A, __dsl_B); } } - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockTexture(Texture* texture) => - Underlying.Value!.UnlockTexture(texture); + public static byte HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B + ) => Underlying.Value!.HasRectIntersectionFloat(A, B); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UnlockTexture(Ref texture) + public static MaybeBool HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B + ) { - fixed (Texture* __dsl_texture = texture) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) { - UnlockTexture(__dsl_texture); + return (MaybeBool)(byte)HasRectIntersectionFloat(__dsl_A, __dsl_B); } } - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UpdateGamepads() => Underlying.Value!.UpdateGamepads(); + public static MaybeBool HasScreenKeyboardSupport() => + Underlying.Value!.HasScreenKeyboardSupport(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data - ) => Underlying.Value!.UpdateHapticEffect(haptic, effect, data); + public static byte HasScreenKeyboardSupportRaw() => + Underlying.Value!.HasScreenKeyboardSupportRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("const SDL_HapticEffect *")] Ref data - ) - { - fixed (HapticEffect* __dsl_data = data) - { - return (MaybeBool)(byte)UpdateHapticEffect(haptic, effect, __dsl_data); - } - } + public static MaybeBool HasSSE() => Underlying.Value!.HasSSE(); - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateJoysticks")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UpdateJoysticks() => Underlying.Value!.UpdateJoysticks(); + public static MaybeBool HasSSE2() => Underlying.Value!.HasSSE2(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateNVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* UVplane, - int UVpitch - ) => Underlying.Value!.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); + public static byte HasSSE2Raw() => Underlying.Value!.HasSSE2Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateNVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref UVplane, - int UVpitch - ) - { - fixed (byte* __dsl_UVplane = UVplane) - fixed (byte* __dsl_Yplane = Yplane) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)UpdateNVTexture( - __dsl_texture, - __dsl_rect, - __dsl_Yplane, - Ypitch, - __dsl_UVplane, - UVpitch - ); - } - } + public static MaybeBool HasSSE3() => Underlying.Value!.HasSSE3(); - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateSensors")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void UpdateSensors() => Underlying.Value!.UpdateSensors(); + public static byte HasSSE3Raw() => Underlying.Value!.HasSSE3Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const void *")] void* pixels, - int pitch - ) => Underlying.Value!.UpdateTexture(texture, rect, pixels, pitch); + public static MaybeBool HasSSE41() => Underlying.Value!.HasSSE41(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const void *")] Ref pixels, - int pitch - ) - { - fixed (void* __dsl_pixels = pixels) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)UpdateTexture(__dsl_texture, __dsl_rect, __dsl_pixels, pitch); - } - } + public static byte HasSSE41Raw() => Underlying.Value!.HasSSE41Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateWindowSurface(WindowHandle window) => - Underlying.Value!.UpdateWindowSurface(window); + public static MaybeBool HasSSE42() => Underlying.Value!.HasSSE42(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateWindowSurfaceRaw(WindowHandle window) => - Underlying.Value!.UpdateWindowSurfaceRaw(window); + public static byte HasSSE42Raw() => Underlying.Value!.HasSSE42Raw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int numrects - ) => Underlying.Value!.UpdateWindowSurfaceRects(window, rects, numrects); + public static byte HasSSERaw() => Underlying.Value!.HasSSERaw(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateWindowSurfaceRects( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int numrects - ) - { - fixed (Rect* __dsl_rects = rects) - { - return (MaybeBool) - (byte)UpdateWindowSurfaceRects(window, __dsl_rects, numrects); - } - } + public static void HidBleScan([NativeTypeName("bool")] byte active) => + Underlying.Value!.HidBleScan(active); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte UpdateYUVTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("const Uint8 *")] byte* Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] byte* Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] byte* Vplane, - int Vpitch - ) => - Underlying.Value!.UpdateYUVTexture( - texture, - rect, - Yplane, - Ypitch, - Uplane, - Upitch, - Vplane, - Vpitch - ); + public static void HidBleScan([NativeTypeName("bool")] MaybeBool active) => + Underlying.Value!.HidBleScan(active); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool UpdateYUVTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("const Uint8 *")] Ref Yplane, - int Ypitch, - [NativeTypeName("const Uint8 *")] Ref Uplane, - int Upitch, - [NativeTypeName("const Uint8 *")] Ref Vplane, - int Vpitch - ) - { - fixed (byte* __dsl_Vplane = Vplane) - fixed (byte* __dsl_Uplane = Uplane) - fixed (byte* __dsl_Yplane = Yplane) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)UpdateYUVTexture( - __dsl_texture, - __dsl_rect, - __dsl_Yplane, - Ypitch, - __dsl_Uplane, - Upitch, - __dsl_Vplane, - Vpitch - ); - } - } + public static int HidClose(HidDeviceHandle dev) => Underlying.Value!.HidClose(dev); - [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WaitCondition(ConditionHandle cond, MutexHandle mutex) => - Underlying.Value!.WaitCondition(cond, mutex); + public static uint HidDeviceChangeCount() => Underlying.Value!.HidDeviceChangeCount(); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WaitConditionTimeout( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS - ) => Underlying.Value!.WaitConditionTimeout(cond, mutex, timeoutMS); + public static Ptr HidEnumerate( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => Underlying.Value!.HidEnumerate(vendor_id, product_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WaitConditionTimeoutRaw( - ConditionHandle cond, - MutexHandle mutex, - [NativeTypeName("Sint32")] int timeoutMS - ) => Underlying.Value!.WaitConditionTimeoutRaw(cond, mutex, timeoutMS); + public static HidDeviceInfo* HidEnumerateRaw( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => Underlying.Value!.HidEnumerateRaw(vendor_id, product_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WaitEvent(Event* @event) => Underlying.Value!.WaitEvent(@event); + public static int HidExit() => Underlying.Value!.HidExit(); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void HidFreeEnumeration(HidDeviceInfo* devs) => + Underlying.Value!.HidFreeEnumeration(devs); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WaitEvent(Ref @event) + public static void HidFreeEnumeration(Ref devs) { - fixed (Event* __dsl_event = @event) + fixed (HidDeviceInfo* __dsl_devs = devs) { - return (MaybeBool)(byte)WaitEvent(__dsl_event); + HidFreeEnumeration(__dsl_devs); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WaitEventTimeout( - Event* @event, - [NativeTypeName("Sint32")] int timeoutMS - ) => Underlying.Value!.WaitEventTimeout(@event, timeoutMS); + public static Ptr HidGetDeviceInfo(HidDeviceHandle dev) => + Underlying.Value!.HidGetDeviceInfo(dev); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => + Underlying.Value!.HidGetDeviceInfoRaw(dev); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => Underlying.Value!.HidGetFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WaitEventTimeout( - Ref @event, - [NativeTypeName("Sint32")] int timeoutMS + public static int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length ) { - fixed (Event* __dsl_event = @event) + fixed (byte* __dsl_data = data) { - return (MaybeBool)(byte)WaitEventTimeout(__dsl_event, timeoutMS); + return (int)HidGetFeatureReport(dev, __dsl_data, length); } } - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WaitSemaphore(SemaphoreHandle sem) => - Underlying.Value!.WaitSemaphore(sem); + public static int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.HidGetIndexedString(dev, string_index, @string, maxlen); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] - [MethodImpl( - MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization - )] - public static MaybeBool WaitSemaphoreTimeout( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS - ) => Underlying.Value!.WaitSemaphoreTimeout(sem, timeoutMS); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WaitSemaphoreTimeoutRaw( - SemaphoreHandle sem, - [NativeTypeName("Sint32")] int timeoutMS - ) => Underlying.Value!.WaitSemaphoreTimeoutRaw(sem, timeoutMS); + public static int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)HidGetIndexedString(dev, string_index, __dsl_string, maxlen); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WaitThread(ThreadHandle thread, int* status) => - Underlying.Value!.WaitThread(thread, status); + public static int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => Underlying.Value!.HidGetInputReport(dev, data, length); [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WaitThread(ThreadHandle thread, Ref status) + public static int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) { - fixed (int* __dsl_status = status) + fixed (byte* __dsl_data = data) { - WaitThread(thread, __dsl_status); + return (int)HidGetInputReport(dev, __dsl_data, length); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WarpMouseGlobal(float x, float y) => - Underlying.Value!.WarpMouseGlobal(x, y); + public static int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.HidGetManufacturerString(dev, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WarpMouseGlobalRaw(float x, float y) => - Underlying.Value!.WarpMouseGlobalRaw(x, y); + public static int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)HidGetManufacturerString(dev, __dsl_string, maxlen); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseInWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static void WarpMouseInWindow(WindowHandle window, float x, float y) => - Underlying.Value!.WarpMouseInWindow(window, x, y); + public static int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.HidGetProductString(dev, @string, maxlen); - [return: NativeTypeName("SDL_InitFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => - Underlying.Value!.WasInit(flags); + public static int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)HidGetProductString(dev, __dsl_string, maxlen); + } + } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WindowHasSurface(WindowHandle window) => - Underlying.Value!.WindowHasSurface(window); + public static int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* buf, + [NativeTypeName("size_t")] nuint buf_size + ) => Underlying.Value!.HidGetReportDescriptor(dev, buf, buf_size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WindowHasSurfaceRaw(WindowHandle window) => - Underlying.Value!.WindowHasSurfaceRaw(window); + public static int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref buf, + [NativeTypeName("size_t")] nuint buf_size + ) + { + fixed (byte* __dsl_buf = buf) + { + return (int)HidGetReportDescriptor(dev, __dsl_buf, buf_size); + } + } - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] void* ptr, - [NativeTypeName("size_t")] nuint size - ) => Underlying.Value!.WriteIO(context, ptr, size); + public static int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.HidGetSerialNumberString(dev, @string, maxlen); - [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static nuint WriteIO( - IOStreamHandle context, - [NativeTypeName("const void *")] Ref ptr, - [NativeTypeName("size_t")] nuint size + public static int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (void* __dsl_ptr = ptr) + fixed (uint* __dsl_string = @string) { - return (nuint)WriteIO(context, __dsl_ptr, size); + return (int)HidGetSerialNumberString(dev, __dsl_string, maxlen); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS16BE( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.WriteS16BE(dst, value); + public static int HidInit() => Underlying.Value!.HidInit(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS16BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.WriteS16BERaw(dst, value); + public static HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] uint* serial_number + ) => Underlying.Value!.HidOpen(vendor_id, product_id, serial_number); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS16LE( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.WriteS16LE(dst, value); + public static HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] Ref serial_number + ) + { + fixed (uint* __dsl_serial_number = serial_number) + { + return (HidDeviceHandle)HidOpen(vendor_id, product_id, __dsl_serial_number); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS16LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint16")] short value - ) => Underlying.Value!.WriteS16LERaw(dst, value); + public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.HidOpenPath(path); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS32BE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => Underlying.Value!.WriteS32BE(dst, value); + public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (HidDeviceHandle)HidOpenPath(__dsl_path); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS32BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => Underlying.Value!.WriteS32BERaw(dst, value); + public static int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => Underlying.Value!.HidRead(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS32LE( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => Underlying.Value!.WriteS32LE(dst, value); + public static int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) + { + fixed (byte* __dsl_data = data) + { + return (int)HidRead(dev, __dsl_data, length); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS32LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint32")] int value - ) => Underlying.Value!.WriteS32LERaw(dst, value); - - [return: NativeTypeName("bool")] + public static int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => Underlying.Value!.HidReadTimeout(dev, data, length, milliseconds); + [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS64BE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => Underlying.Value!.WriteS64BE(dst, value); + public static int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) + { + fixed (byte* __dsl_data = data) + { + return (int)HidReadTimeout(dev, __dsl_data, length, milliseconds); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS64BERaw( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => Underlying.Value!.WriteS64BERaw(dst, value); + public static int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => Underlying.Value!.HidSendFeatureReport(dev, data, length); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS64LE( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => Underlying.Value!.WriteS64LE(dst, value); + public static int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) + { + fixed (byte* __dsl_data = data) + { + return (int)HidSendFeatureReport(dev, __dsl_data, length); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS64LERaw( - IOStreamHandle dst, - [NativeTypeName("Sint64")] long value - ) => Underlying.Value!.WriteS64LERaw(dst, value); + public static int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => + Underlying.Value!.HidSetNonblocking(dev, nonblock); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => Underlying.Value!.HidWrite(dev, data, length); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) + { + fixed (byte* __dsl_data = data) + { + return (int)HidWrite(dev, __dsl_data, length); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteS8( - IOStreamHandle dst, - [NativeTypeName("Sint8")] sbyte value - ) => Underlying.Value!.WriteS8(dst, value); + public static MaybeBool HideCursor() => Underlying.Value!.HideCursor(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteS8Raw(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => - Underlying.Value!.WriteS8Raw(dst, value); + public static byte HideCursorRaw() => Underlying.Value!.HideCursorRaw(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const void *")] void* source, - [NativeTypeName("Uint64")] ulong length - ) => Underlying.Value!.WriteStorageFile(storage, path, source, length); + public static MaybeBool HideWindow(WindowHandle window) => + Underlying.Value!.HideWindow(window); [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte HideWindowRaw(WindowHandle window) => + Underlying.Value!.HideWindowRaw(window); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ) => Underlying.Value!.Iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); + + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const void *")] Ref source, - [NativeTypeName("Uint64")] ulong length + public static nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft ) { - fixed (void* __dsl_source = source) - fixed (sbyte* __dsl_path = path) + fixed (nuint* __dsl_outbytesleft = outbytesleft) + fixed (sbyte** __dsl_outbuf = outbuf) + fixed (nuint* __dsl_inbytesleft = inbytesleft) + fixed (sbyte** __dsl_inbuf = inbuf) { - return (MaybeBool) - (byte)WriteStorageFile(storage, __dsl_path, __dsl_source, length); + return (nuint)Iconv( + cd, + __dsl_inbuf, + __dsl_inbytesleft, + __dsl_outbuf, + __dsl_outbytesleft + ); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_close")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => Underlying.Value!.WriteSurfacePixel(surface, x, y, r, g, b, a); + public static int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd) => + Underlying.Value!.IconvClose(cd); - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_iconv_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ) => Underlying.Value!.IconvOpen(tocode, fromcode); + + [return: NativeTypeName("SDL_iconv_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + public static IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) { - return (MaybeBool)(byte)WriteSurfacePixel(__dsl_surface, x, y, r, g, b, a); + return (IconvDataTHandle)IconvOpen(__dsl_tocode, __dsl_fromcode); } } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteSurfacePixelFloat( - Surface* surface, - int x, - int y, - float r, - float g, - float b, - float a - ) => Underlying.Value!.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + public static sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => Underlying.Value!.IconvString(tocode, fromcode, inbuf, inbytesleft); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteSurfacePixelFloat( - Ref surface, - int x, - int y, - float r, - float g, - float b, - float a + public static Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_inbuf = inbuf) + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) { - return (MaybeBool) - (byte)WriteSurfacePixelFloat(__dsl_surface, x, y, r, g, b, a); + return (sbyte*)IconvString(__dsl_tocode, __dsl_fromcode, __dsl_inbuf, inbytesleft); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU16BE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => Underlying.Value!.WriteU16BE(dst, value); + public static MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.Init(flags); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU16BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => Underlying.Value!.WriteU16BERaw(dst, value); + public static MaybeBool InitHapticRumble(HapticHandle haptic) => + Underlying.Value!.InitHapticRumble(haptic); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU16LE( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => Underlying.Value!.WriteU16LE(dst, value); + public static byte InitHapticRumbleRaw(HapticHandle haptic) => + Underlying.Value!.InitHapticRumbleRaw(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU16LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint16")] ushort value - ) => Underlying.Value!.WriteU16LERaw(dst, value); + public static byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.InitRaw(flags); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU32BE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => Underlying.Value!.WriteU32BE(dst, value); + public static MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.InitSubSystem(flags); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU32BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => Underlying.Value!.WriteU32BERaw(dst, value); + public static byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.InitSubSystemRaw(flags); + + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ) => Underlying.Value!.InsertGPUDebugLabel(command_buffer, text); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU32LE( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => Underlying.Value!.WriteU32LE(dst, value); + public static void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + InsertGPUDebugLabel(command_buffer, __dsl_text); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU32LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint32")] uint value - ) => Underlying.Value!.WriteU32LERaw(dst, value); + public static IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] void* mem, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.IOFromConstMem(mem, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU64BE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => Underlying.Value!.WriteU64BE(dst, value); + public static IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] Ref mem, + [NativeTypeName("size_t")] nuint size + ) + { + fixed (void* __dsl_mem = mem) + { + return (IOStreamHandle)IOFromConstMem(__dsl_mem, size); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU64BERaw( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => Underlying.Value!.WriteU64BERaw(dst, value); + public static IOStreamHandle IOFromDynamicMem() => Underlying.Value!.IOFromDynamicMem(); + + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("const char *")] sbyte* mode + ) => Underlying.Value!.IOFromFile(file, mode); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU64LE( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => Underlying.Value!.WriteU64LE(dst, value); + public static IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("const char *")] Ref mode + ) + { + fixed (sbyte* __dsl_mode = mode) + fixed (sbyte* __dsl_file = file) + { + return (IOStreamHandle)IOFromFile(__dsl_file, __dsl_mode); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU64LERaw( - IOStreamHandle dst, - [NativeTypeName("Uint64")] ulong value - ) => Underlying.Value!.WriteU64LERaw(dst, value); + public static IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => + Underlying.Value!.IOFromMem(mem, size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static MaybeBool WriteU8( - IOStreamHandle dst, - [NativeTypeName("Uint8")] byte value - ) => Underlying.Value!.WriteU8(dst, value); + public static IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) + { + fixed (void* __dsl_mem = mem) + { + return (IOStreamHandle)IOFromMem(__dsl_mem, size); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] [MethodImpl( MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization )] - public static byte WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => - Underlying.Value!.WriteU8Raw(dst, value); - } - - [NativeTypeName("#define SDL_ASSERT_LEVEL 2")] - public const int AssertLevel = 2; + public static nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.IOvprintf(context, fmt, ap); - [NativeTypeName("#define SDL_FILE __FILE__")] - public static Utf8String File => - "/Users/dylan/Documents/Silk.NET3/eng/silktouch/sdl/SDL3/sdl-SDL.h"u8; + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + { + return (nuint)IOvprintf(context, __dsl_fmt, __dsl_ap); + } + } - [NativeTypeName("#define SDL_LINE __LINE__")] - public const int Line = 7; + [NativeFunction("SDL3", EntryPoint = "SDL_isalnum")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isalnum(int x) => Underlying.Value!.Isalnum(x); - [NativeTypeName("#define SDL_NULL_WHILE_LOOP_CONDITION (0)")] - public const int NullWhileLoopCondition = (0); + [NativeFunction("SDL3", EntryPoint = "SDL_isalpha")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isalpha(int x) => Underlying.Value!.Isalpha(x); - [NativeTypeName( - "#define SDL_PROP_THREAD_CREATE_ENTRY_FUNCTION_POINTER \"SDL.thread.create.entry_function\"" - )] - public static Utf8String PropThreadCreateEntryFunctionPointer => - "SDL.thread.create.entry_function"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isblank")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isblank(int x) => Underlying.Value!.Isblank(x); - [NativeTypeName("#define SDL_PROP_THREAD_CREATE_NAME_STRING \"SDL.thread.create.name\"")] - public static Utf8String PropThreadCreateNameString => "SDL.thread.create.name"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_iscntrl")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Iscntrl(int x) => Underlying.Value!.Iscntrl(x); - [NativeTypeName( - "#define SDL_PROP_THREAD_CREATE_USERDATA_POINTER \"SDL.thread.create.userdata\"" - )] - public static Utf8String PropThreadCreateUserdataPointer => "SDL.thread.create.userdata"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isdigit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isdigit(int x) => Underlying.Value!.Isdigit(x); - [NativeTypeName( - "#define SDL_PROP_THREAD_CREATE_STACKSIZE_NUMBER \"SDL.thread.create.stacksize\"" - )] - public static Utf8String PropThreadCreateStacksizeNumber => "SDL.thread.create.stacksize"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsGamepad( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.IsGamepad(instance_id); - [NativeTypeName( - "#define SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER \"SDL.iostream.windows.handle\"" - )] - public static Utf8String PropIostreamWindowsHandlePointer => "SDL.iostream.windows.handle"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + Underlying.Value!.IsGamepadRaw(instance_id); - [NativeTypeName("#define SDL_PROP_IOSTREAM_STDIO_FILE_POINTER \"SDL.iostream.stdio.file\"")] - public static Utf8String PropIostreamStdioFilePointer => "SDL.iostream.stdio.file"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isgraph")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isgraph(int x) => Underlying.Value!.Isgraph(x); - [NativeTypeName( - "#define SDL_PROP_IOSTREAM_FILE_DESCRIPTOR_NUMBER \"SDL.iostream.file_descriptor\"" - )] - public static Utf8String PropIostreamFileDescriptorNumber => "SDL.iostream.file_descriptor"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isinf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isinf(double x) => Underlying.Value!.Isinf(x); - [NativeTypeName( - "#define SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER \"SDL.iostream.android.aasset\"" - )] - public static Utf8String PropIostreamAndroidAassetPointer => "SDL.iostream.android.aasset"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isinff")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isinff(float x) => Underlying.Value!.Isinff(x); - [NativeTypeName("#define SDL_PROP_IOSTREAM_MEMORY_POINTER \"SDL.iostream.memory.base\"")] - public static Utf8String PropIostreamMemoryPointer => "SDL.iostream.memory.base"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsJoystickHaptic(JoystickHandle joystick) => + Underlying.Value!.IsJoystickHaptic(joystick); - [NativeTypeName("#define SDL_PROP_IOSTREAM_MEMORY_SIZE_NUMBER \"SDL.iostream.memory.size\"")] - public static Utf8String PropIostreamMemorySizeNumber => "SDL.iostream.memory.size"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsJoystickHapticRaw(JoystickHandle joystick) => + Underlying.Value!.IsJoystickHapticRaw(joystick); - [NativeTypeName( - "#define SDL_PROP_IOSTREAM_DYNAMIC_MEMORY_POINTER \"SDL.iostream.dynamic.memory\"" - )] - public static Utf8String PropIostreamDynamicMemoryPointer => "SDL.iostream.dynamic.memory"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsJoystickVirtual( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.IsJoystickVirtual(instance_id); - [NativeTypeName( - "#define SDL_PROP_IOSTREAM_DYNAMIC_CHUNKSIZE_NUMBER \"SDL.iostream.dynamic.chunksize\"" - )] - public static Utf8String PropIostreamDynamicChunksizeNumber => - "SDL.iostream.dynamic.chunksize"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsJoystickVirtualRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.IsJoystickVirtualRaw(instance_id); - [NativeTypeName("#define SDL_AUDIO_MASK_BITSIZE (0xFFu)")] - public const uint AudioMaskBitsize = (0xFFU); + [NativeFunction("SDL3", EntryPoint = "SDL_islower")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Islower(int x) => Underlying.Value!.Islower(x); - [NativeTypeName("#define SDL_AUDIO_MASK_FLOAT (1u<<8)")] - public const uint AudioMaskFloat = (1U << 8); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsMouseHaptic() => Underlying.Value!.IsMouseHaptic(); - [NativeTypeName("#define SDL_AUDIO_MASK_BIG_ENDIAN (1u<<12)")] - public const uint AudioMaskBigEndian = (1U << 12); - - [NativeTypeName("#define SDL_AUDIO_MASK_SIGNED (1u<<15)")] - public const uint AudioMaskSigned = (1U << 15); - - [NativeTypeName("#define SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK ((SDL_AudioDeviceID) 0xFFFFFFFFu)")] - public const uint AudioDeviceDefaultPlayback = ((uint)(0xFFFFFFFFU)); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsMouseHapticRaw() => Underlying.Value!.IsMouseHapticRaw(); - [NativeTypeName("#define SDL_AUDIO_DEVICE_DEFAULT_RECORDING ((SDL_AudioDeviceID) 0xFFFFFFFEu)")] - public const uint AudioDeviceDefaultRecording = ((uint)(0xFFFFFFFEU)); + [NativeFunction("SDL3", EntryPoint = "SDL_isnan")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isnan(double x) => Underlying.Value!.Isnan(x); - [NativeTypeName("#define SDL_ALPHA_OPAQUE 255")] - public const int AlphaOpaque = 255; + [NativeFunction("SDL3", EntryPoint = "SDL_isnanf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isnanf(float x) => Underlying.Value!.Isnanf(x); - [NativeTypeName("#define SDL_ALPHA_OPAQUE_FLOAT 1.0f")] - public const float AlphaOpaqueFloat = 1.0f; + [NativeFunction("SDL3", EntryPoint = "SDL_isprint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isprint(int x) => Underlying.Value!.Isprint(x); - [NativeTypeName("#define SDL_ALPHA_TRANSPARENT 0")] - public const int AlphaTransparent = 0; + [NativeFunction("SDL3", EntryPoint = "SDL_ispunct")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Ispunct(int x) => Underlying.Value!.Ispunct(x); - [NativeTypeName("#define SDL_ALPHA_TRANSPARENT_FLOAT 0.0f")] - public const float AlphaTransparentFloat = 0.0f; + [NativeFunction("SDL3", EntryPoint = "SDL_isspace")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isspace(int x) => Underlying.Value!.Isspace(x); - [NativeTypeName("#define SDL_SURFACE_PREALLOCATED 0x00000001u")] - public const uint SurfacePreallocated = 0x00000001U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsTablet() => Underlying.Value!.IsTablet(); - [NativeTypeName("#define SDL_SURFACE_LOCK_NEEDED 0x00000002u")] - public const uint SurfaceLockNeeded = 0x00000002U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsTabletRaw() => Underlying.Value!.IsTabletRaw(); - [NativeTypeName("#define SDL_SURFACE_LOCKED 0x00000004u")] - public const uint SurfaceLocked = 0x00000004U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool IsTV() => Underlying.Value!.IsTV(); - [NativeTypeName("#define SDL_SURFACE_SIMD_ALIGNED 0x00000008u")] - public const uint SurfaceSimdAligned = 0x00000008U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte IsTVRaw() => Underlying.Value!.IsTVRaw(); - [NativeTypeName( - "#define SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT \"SDL.surface.SDR_white_point\"" - )] - public static Utf8String PropSurfaceSdrWhitePointFloat => "SDL.surface.SDR_white_point"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isupper")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isupper(int x) => Underlying.Value!.Isupper(x); - [NativeTypeName("#define SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT \"SDL.surface.HDR_headroom\"")] - public static Utf8String PropSurfaceHdrHeadroomFloat => "SDL.surface.HDR_headroom"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_isxdigit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Isxdigit(int x) => Underlying.Value!.Isxdigit(x); - [NativeTypeName("#define SDL_PROP_SURFACE_TONEMAP_OPERATOR_STRING \"SDL.surface.tonemap\"")] - public static Utf8String PropSurfaceTonemapOperatorString => "SDL.surface.tonemap"u8; + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix) => + Underlying.Value!.Itoa(value, str, radix); - [NativeTypeName("#define SDL_CACHELINE_SIZE 128")] - public const int CachelineSize = 128; + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Itoa( + int value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Itoa(value, __dsl_str, radix); + } + } - [NativeTypeName( - "#define SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER \"SDL.video.wayland.wl_display\"" - )] - public static Utf8String PropGlobalVideoWaylandWlDisplayPointer => - "SDL.video.wayland.wl_display"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool JoystickConnected(JoystickHandle joystick) => + Underlying.Value!.JoystickConnected(joystick); - [NativeTypeName("#define SDL_WINDOW_FULLSCREEN SDL_UINT64_C(0x0000000000000001)")] - public const ulong WindowFullscreen = (0x0000000000000001UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte JoystickConnectedRaw(JoystickHandle joystick) => + Underlying.Value!.JoystickConnectedRaw(joystick); - [NativeTypeName("#define SDL_WINDOW_OPENGL SDL_UINT64_C(0x0000000000000002)")] - public const ulong WindowOpengl = (0x0000000000000002UL); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool JoystickEventsEnabled() => + Underlying.Value!.JoystickEventsEnabled(); - [NativeTypeName("#define SDL_WINDOW_OCCLUDED SDL_UINT64_C(0x0000000000000004)")] - public const ulong WindowOccluded = (0x0000000000000004UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte JoystickEventsEnabledRaw() => + Underlying.Value!.JoystickEventsEnabledRaw(); - [NativeTypeName("#define SDL_WINDOW_HIDDEN SDL_UINT64_C(0x0000000000000008)")] - public const ulong WindowHidden = (0x0000000000000008UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte force + ) => Underlying.Value!.KillProcess(process, force); - [NativeTypeName("#define SDL_WINDOW_BORDERLESS SDL_UINT64_C(0x0000000000000010)")] - public const ulong WindowBorderless = (0x0000000000000010UL); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ) => Underlying.Value!.KillProcess(process, force); - [NativeTypeName("#define SDL_WINDOW_RESIZABLE SDL_UINT64_C(0x0000000000000020)")] - public const ulong WindowResizable = (0x0000000000000020UL); + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => Underlying.Value!.Lltoa(value, str, radix); - [NativeTypeName("#define SDL_WINDOW_MINIMIZED SDL_UINT64_C(0x0000000000000040)")] - public const ulong WindowMinimized = (0x0000000000000040UL); + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Lltoa(value, __dsl_str, radix); + } + } - [NativeTypeName("#define SDL_WINDOW_MAXIMIZED SDL_UINT64_C(0x0000000000000080)")] - public const ulong WindowMaximized = (0x0000000000000080UL); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => + Underlying.Value!.LoadBMP(file); - [NativeTypeName("#define SDL_WINDOW_MOUSE_GRABBED SDL_UINT64_C(0x0000000000000100)")] - public const ulong WindowMouseGrabbed = (0x0000000000000100UL); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr LoadBMP([NativeTypeName("const char *")] Ref file) + { + fixed (sbyte* __dsl_file = file) + { + return (Surface*)LoadBMP(__dsl_file); + } + } - [NativeTypeName("#define SDL_WINDOW_INPUT_FOCUS SDL_UINT64_C(0x0000000000000200)")] - public const ulong WindowInputFocus = (0x0000000000000200UL); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Surface* LoadBMPIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio + ) => Underlying.Value!.LoadBMPIO(src, closeio); - [NativeTypeName("#define SDL_WINDOW_MOUSE_FOCUS SDL_UINT64_C(0x0000000000000400)")] - public const ulong WindowMouseFocus = (0x0000000000000400UL); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr LoadBMPIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => Underlying.Value!.LoadBMPIO(src, closeio); - [NativeTypeName("#define SDL_WINDOW_EXTERNAL SDL_UINT64_C(0x0000000000000800)")] - public const ulong WindowExternal = (0x0000000000000800UL); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* LoadFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("size_t *")] nuint* datasize + ) => Underlying.Value!.LoadFile(file, datasize); - [NativeTypeName("#define SDL_WINDOW_MODAL SDL_UINT64_C(0x0000000000001000)")] - public const ulong WindowModal = (0x0000000000001000UL); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr LoadFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("size_t *")] Ref datasize + ) + { + fixed (nuint* __dsl_datasize = datasize) + fixed (sbyte* __dsl_file = file) + { + return (void*)LoadFile(__dsl_file, __dsl_datasize); + } + } - [NativeTypeName("#define SDL_WINDOW_HIGH_PIXEL_DENSITY SDL_UINT64_C(0x0000000000002000)")] - public const ulong WindowHighPixelDensity = (0x0000000000002000UL); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] nuint* datasize, + [NativeTypeName("bool")] byte closeio + ) => Underlying.Value!.LoadFileIO(src, datasize, closeio); - [NativeTypeName("#define SDL_WINDOW_MOUSE_CAPTURE SDL_UINT64_C(0x0000000000004000)")] - public const ulong WindowMouseCapture = (0x0000000000004000UL); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] Ref datasize, + [NativeTypeName("bool")] MaybeBool closeio + ) + { + fixed (nuint* __dsl_datasize = datasize) + { + return (void*)LoadFileIO(src, __dsl_datasize, (byte)closeio); + } + } - [NativeTypeName("#define SDL_WINDOW_MOUSE_RELATIVE_MODE SDL_UINT64_C(0x0000000000008000)")] - public const ulong WindowMouseRelativeMode = (0x0000000000008000UL); + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.LoadFunction(handle, name); - [NativeTypeName("#define SDL_WINDOW_ALWAYS_ON_TOP SDL_UINT64_C(0x0000000000010000)")] - public const ulong WindowAlwaysOnTop = (0x0000000000010000UL); + [return: NativeTypeName("SDL_FunctionPointer")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (FunctionPointer)LoadFunction(handle, __dsl_name); + } + } - [NativeTypeName("#define SDL_WINDOW_UTILITY SDL_UINT64_C(0x0000000000020000)")] - public const ulong WindowUtility = (0x0000000000020000UL); + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static SharedObjectHandle LoadObject( + [NativeTypeName("const char *")] sbyte* sofile + ) => Underlying.Value!.LoadObject(sofile); - [NativeTypeName("#define SDL_WINDOW_TOOLTIP SDL_UINT64_C(0x0000000000040000)")] - public const ulong WindowTooltip = (0x0000000000040000UL); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static SharedObjectHandle LoadObject( + [NativeTypeName("const char *")] Ref sofile + ) + { + fixed (sbyte* __dsl_sofile = sofile) + { + return (SharedObjectHandle)LoadObject(__dsl_sofile); + } + } - [NativeTypeName("#define SDL_WINDOW_POPUP_MENU SDL_UINT64_C(0x0000000000080000)")] - public const ulong WindowPopupMenu = (0x0000000000080000UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LoadWAV( + [NativeTypeName("const char *")] sbyte* path, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => Underlying.Value!.LoadWAV(path, spec, audio_buf, audio_len); - [NativeTypeName("#define SDL_WINDOW_KEYBOARD_GRABBED SDL_UINT64_C(0x0000000000100000)")] - public const ulong WindowKeyboardGrabbed = (0x0000000000100000UL); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LoadWAV( + [NativeTypeName("const char *")] Ref path, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) + { + fixed (uint* __dsl_audio_len = audio_len) + fixed (byte** __dsl_audio_buf = audio_buf) + fixed (AudioSpec* __dsl_spec = spec) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)LoadWAV(__dsl_path, __dsl_spec, __dsl_audio_buf, __dsl_audio_len); + } + } - [NativeTypeName("#define SDL_WINDOW_VULKAN SDL_UINT64_C(0x0000000010000000)")] - public const ulong WindowVulkan = (0x0000000010000000UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => Underlying.Value!.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); - [NativeTypeName("#define SDL_WINDOW_METAL SDL_UINT64_C(0x0000000020000000)")] - public const ulong WindowMetal = (0x0000000020000000UL); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) + { + fixed (uint* __dsl_audio_len = audio_len) + fixed (byte** __dsl_audio_buf = audio_buf) + fixed (AudioSpec* __dsl_spec = spec) + { + return (MaybeBool) + (byte)LoadWAVIO( + src, + (byte)closeio, + __dsl_spec, + __dsl_audio_buf, + __dsl_audio_len + ); + } + } - [NativeTypeName("#define SDL_WINDOW_TRANSPARENT SDL_UINT64_C(0x0000000040000000)")] - public const ulong WindowTransparent = (0x0000000040000000UL); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LockAudioStream(AudioStreamHandle stream) => + Underlying.Value!.LockAudioStream(stream); - [NativeTypeName("#define SDL_WINDOW_NOT_FOCUSABLE SDL_UINT64_C(0x0000000080000000)")] - public const ulong WindowNotFocusable = (0x0000000080000000UL); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LockAudioStreamRaw(AudioStreamHandle stream) => + Underlying.Value!.LockAudioStreamRaw(stream); - [NativeTypeName("#define SDL_WINDOWPOS_UNDEFINED_MASK 0x1FFF0000u")] - public const uint WindowposUndefinedMask = 0x1FFF0000U; + [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockJoysticks() => Underlying.Value!.LockJoysticks(); - [NativeTypeName("#define SDL_WINDOWPOS_UNDEFINED SDL_WINDOWPOS_UNDEFINED_DISPLAY(0)")] - public const uint WindowposUndefined = (0x1FFF0000U | (0)); + [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockMutex(MutexHandle mutex) => Underlying.Value!.LockMutex(mutex); - [NativeTypeName("#define SDL_WINDOWPOS_CENTERED_MASK 0x2FFF0000u")] - public const uint WindowposCenteredMask = 0x2FFF0000U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LockProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.LockProperties(props); - [NativeTypeName("#define SDL_WINDOWPOS_CENTERED SDL_WINDOWPOS_CENTERED_DISPLAY(0)")] - public const uint WindowposCentered = (0x2FFF0000U | (0)); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + Underlying.Value!.LockPropertiesRaw(props); - [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_CORE 0x0001")] - public const int GlContextProfileCore = 0x0001; + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockRWLockForReading(RWLockHandle rwlock) => + Underlying.Value!.LockRWLockForReading(rwlock); - [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_COMPATIBILITY 0x0002")] - public const int GlContextProfileCompatibility = 0x0002; + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockRWLockForWriting(RWLockHandle rwlock) => + Underlying.Value!.LockRWLockForWriting(rwlock); - [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_ES 0x0004")] - public const int GlContextProfileEs = 0x0004; + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + Underlying.Value!.LockSpinlock(@lock); - [NativeTypeName("#define SDL_GL_CONTEXT_DEBUG_FLAG 0x0001")] - public const int GlContextDebugFlag = 0x0001; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + { + fixed (int* __dsl_lock = @lock) + { + LockSpinlock(__dsl_lock); + } + } - [NativeTypeName("#define SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG 0x0002")] - public const int GlContextForwardCompatibleFlag = 0x0002; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LockSurface(Surface* surface) => Underlying.Value!.LockSurface(surface); - [NativeTypeName("#define SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG 0x0004")] - public const int GlContextRobustAccessFlag = 0x0004; - - [NativeTypeName("#define SDL_GL_CONTEXT_RESET_ISOLATION_FLAG 0x0008")] - public const int GlContextResetIsolationFlag = 0x0008; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LockSurface(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)LockSurface(__dsl_surface); + } + } - [NativeTypeName("#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE 0x0000")] - public const int GlContextReleaseBehaviorNone = 0x0000; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LockTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + void** pixels, + int* pitch + ) => Underlying.Value!.LockTexture(texture, rect, pixels, pitch); - [NativeTypeName("#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x0001")] - public const int GlContextReleaseBehaviorFlush = 0x0001; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LockTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D pixels, + Ref pitch + ) + { + fixed (int* __dsl_pitch = pitch) + fixed (void** __dsl_pixels = pixels) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)LockTexture(__dsl_texture, __dsl_rect, __dsl_pixels, __dsl_pitch); + } + } - [NativeTypeName("#define SDL_GL_CONTEXT_RESET_NO_NOTIFICATION 0x0000")] - public const int GlContextResetNoNotification = 0x0000; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte LockTextureToSurface( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + Surface** surface + ) => Underlying.Value!.LockTextureToSurface(texture, rect, surface); - [NativeTypeName("#define SDL_GL_CONTEXT_RESET_LOSE_CONTEXT 0x0001")] - public const int GlContextResetLoseContext = 0x0001; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool LockTextureToSurface( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D surface + ) + { + fixed (Surface** __dsl_surface = surface) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)LockTextureToSurface(__dsl_texture, __dsl_rect, __dsl_surface); + } + } - [NativeTypeName("#define SDL_PROP_DISPLAY_HDR_ENABLED_BOOLEAN \"SDL.display.HDR_enabled\"")] - public static Utf8String PropDisplayHdrEnabledBoolean => "SDL.display.HDR_enabled"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_log")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Log(double x) => Underlying.Value!.Log(x); - [NativeTypeName( - "#define SDL_PROP_DISPLAY_KMSDRM_PANEL_ORIENTATION_NUMBER \"SDL.display.KMSDRM.panel_orientation\"" - )] - public static Utf8String PropDisplayKmsdrmPanelOrientationNumber => - "SDL.display.KMSDRM.panel_orientation"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_log10")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Log10(double x) => Underlying.Value!.Log10(x); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN \"SDL.window.create.always_on_top\"" - )] - public static Utf8String PropWindowCreateAlwaysOnTopBoolean => - "SDL.window.create.always_on_top"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_log10f")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Log10F(float x) => Underlying.Value!.Log10F(x); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN \"SDL.window.create.borderless\"" - )] - public static Utf8String PropWindowCreateBorderlessBoolean => "SDL.window.create.borderless"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_logf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Logf(float x) => Underlying.Value!.Logf(x); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN \"SDL.window.create.focusable\"" - )] - public static Utf8String PropWindowCreateFocusableBoolean => "SDL.window.create.focusable"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.LogMessageV(category, priority, fmt, ap); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN \"SDL.window.create.external_graphics_context\"" - )] - public static Utf8String PropWindowCreateExternalGraphicsContextBoolean => - "SDL.window.create.external_graphics_context"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + { + LogMessageV(category, priority, __dsl_fmt, __dsl_ap); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER \"SDL.window.create.flags\"")] - public static Utf8String PropWindowCreateFlagsNumber => "SDL.window.create.flags"u8; + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lround")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Lround(double x) => Underlying.Value!.Lround(x); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN \"SDL.window.create.fullscreen\"" - )] - public static Utf8String PropWindowCreateFullscreenBoolean => "SDL.window.create.fullscreen"u8; + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lroundf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Lroundf(float x) => Underlying.Value!.Lroundf(x); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER \"SDL.window.create.height\"")] - public static Utf8String PropWindowCreateHeightNumber => "SDL.window.create.height"u8; + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => Underlying.Value!.Ltoa(value, str, radix); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN \"SDL.window.create.hidden\"")] - public static Utf8String PropWindowCreateHiddenBoolean => "SDL.window.create.hidden"u8; + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ltoa(value, __dsl_str, radix); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN \"SDL.window.create.high_pixel_density\"" - )] - public static Utf8String PropWindowCreateHighPixelDensityBoolean => - "SDL.window.create.high_pixel_density"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv) => + Underlying.Value!.Main(argc, argv); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN \"SDL.window.create.maximized\"" - )] - public static Utf8String PropWindowCreateMaximizedBoolean => "SDL.window.create.maximized"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv) + { + fixed (sbyte** __dsl_argv = argv) + { + return (int)Main(argc, __dsl_argv); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN \"SDL.window.create.menu\"")] - public static Utf8String PropWindowCreateMenuBoolean => "SDL.window.create.menu"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Malloc([NativeTypeName("size_t")] nuint size) => + Underlying.Value!.Malloc(size); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN \"SDL.window.create.metal\"")] - public static Utf8String PropWindowCreateMetalBoolean => "SDL.window.create.metal"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* MallocRaw([NativeTypeName("size_t")] nuint size) => + Underlying.Value!.MallocRaw(size); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN \"SDL.window.create.minimized\"" - )] - public static Utf8String PropWindowCreateMinimizedBoolean => "SDL.window.create.minimized"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ) => Underlying.Value!.MapGPUTransferBuffer(device, transfer_buffer, cycle); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN \"SDL.window.create.modal\"")] - public static Utf8String PropWindowCreateModalBoolean => "SDL.window.create.modal"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ) => Underlying.Value!.MapGPUTransferBuffer(device, transfer_buffer, cycle); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN \"SDL.window.create.mouse_grabbed\"" - )] - public static Utf8String PropWindowCreateMouseGrabbedBoolean => - "SDL.window.create.mouse_grabbed"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => Underlying.Value!.MapRGB(format, palette, r, g, b); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN \"SDL.window.create.opengl\"")] - public static Utf8String PropWindowCreateOpenglBoolean => "SDL.window.create.opengl"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + return (uint)MapRGB(__dsl_format, __dsl_palette, r, g, b); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_PARENT_POINTER \"SDL.window.create.parent\"")] - public static Utf8String PropWindowCreateParentPointer => "SDL.window.create.parent"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => Underlying.Value!.MapRgba(format, palette, r, g, b, a); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN \"SDL.window.create.resizable\"" - )] - public static Utf8String PropWindowCreateResizableBoolean => "SDL.window.create.resizable"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + return (uint)MapRgba(__dsl_format, __dsl_palette, r, g, b, a); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_TITLE_STRING \"SDL.window.create.title\"")] - public static Utf8String PropWindowCreateTitleString => "SDL.window.create.title"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapSurfaceRGB( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => Underlying.Value!.MapSurfaceRGB(surface, r, g, b); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN \"SDL.window.create.transparent\"" - )] - public static Utf8String PropWindowCreateTransparentBoolean => - "SDL.window.create.transparent"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapSurfaceRGB( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (uint)MapSurfaceRGB(__dsl_surface, r, g, b); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN \"SDL.window.create.tooltip\"")] - public static Utf8String PropWindowCreateTooltipBoolean => "SDL.window.create.tooltip"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapSurfaceRgba( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => Underlying.Value!.MapSurfaceRgba(surface, r, g, b, a); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN \"SDL.window.create.utility\"")] - public static Utf8String PropWindowCreateUtilityBoolean => "SDL.window.create.utility"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint MapSurfaceRgba( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (uint)MapSurfaceRgba(__dsl_surface, r, g, b, a); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN \"SDL.window.create.vulkan\"")] - public static Utf8String PropWindowCreateVulkanBoolean => "SDL.window.create.vulkan"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool MaximizeWindow(WindowHandle window) => + Underlying.Value!.MaximizeWindow(window); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER \"SDL.window.create.width\"")] - public static Utf8String PropWindowCreateWidthNumber => "SDL.window.create.width"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte MaximizeWindowRaw(WindowHandle window) => + Underlying.Value!.MaximizeWindowRaw(window); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_X_NUMBER \"SDL.window.create.x\"")] - public static Utf8String PropWindowCreateXNumber => "SDL.window.create.x"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ) => Underlying.Value!.Memcmp(s1, s2, len); - [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_Y_NUMBER \"SDL.window.create.y\"")] - public static Utf8String PropWindowCreateYNumber => "SDL.window.create.y"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_s2 = s2) + fixed (void* __dsl_s1 = s1) + { + return (int)Memcmp(__dsl_s1, __dsl_s2, len); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER \"SDL.window.create.cocoa.window\"" - )] - public static Utf8String PropWindowCreateCocoaWindowPointer => - "SDL.window.create.cocoa.window"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void MemoryBarrierAcquireFunction() => + Underlying.Value!.MemoryBarrierAcquireFunction(); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER \"SDL.window.create.cocoa.view\"" - )] - public static Utf8String PropWindowCreateCocoaViewPointer => "SDL.window.create.cocoa.view"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void MemoryBarrierReleaseFunction() => + Underlying.Value!.MemoryBarrierReleaseFunction(); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN \"SDL.window.create.wayland.surface_role_custom\"" - )] - public static Utf8String PropWindowCreateWaylandSurfaceRoleCustomBoolean => - "SDL.window.create.wayland.surface_role_custom"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => Underlying.Value!.Memset4(dst, val, dwords); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN \"SDL.window.create.wayland.create_egl_window\"" - )] - public static Utf8String PropWindowCreateWaylandCreateEglWindowBoolean => - "SDL.window.create.wayland.create_egl_window"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) + { + fixed (void* __dsl_dst = dst) + { + return (void*)Memset4(__dsl_dst, val, dwords); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER \"SDL.window.create.wayland.wl_surface\"" - )] - public static Utf8String PropWindowCreateWaylandWlSurfacePointer => - "SDL.window.create.wayland.wl_surface"u8; + [return: NativeTypeName("SDL_MetalView")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr MetalCreateView(WindowHandle window) => + Underlying.Value!.MetalCreateView(window); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER \"SDL.window.create.win32.hwnd\"" - )] - public static Utf8String PropWindowCreateWin32HwndPointer => "SDL.window.create.win32.hwnd"u8; + [return: NativeTypeName("SDL_MetalView")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* MetalCreateViewRaw(WindowHandle window) => + Underlying.Value!.MetalCreateViewRaw(window); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER \"SDL.window.create.win32.pixel_format_hwnd\"" - )] - public static Utf8String PropWindowCreateWin32PixelFormatHwndPointer => - "SDL.window.create.win32.pixel_format_hwnd"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => + Underlying.Value!.MetalDestroyView(view); - [NativeTypeName( - "#define SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER \"SDL.window.create.x11.window\"" - )] - public static Utf8String PropWindowCreateX11WindowNumber => "SDL.window.create.x11.window"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) + { + fixed (void* __dsl_view = view) + { + MetalDestroyView(__dsl_view); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_SHAPE_POINTER \"SDL.window.shape\"")] - public static Utf8String PropWindowShapePointer => "SDL.window.shape"u8; - - [NativeTypeName("#define SDL_PROP_WINDOW_HDR_ENABLED_BOOLEAN \"SDL.window.HDR_enabled\"")] - public static Utf8String PropWindowHdrEnabledBoolean => "SDL.window.HDR_enabled"u8; - - [NativeTypeName("#define SDL_PROP_WINDOW_SDR_WHITE_LEVEL_FLOAT \"SDL.window.SDR_white_level\"")] - public static Utf8String PropWindowSdrWhiteLevelFloat => "SDL.window.SDR_white_level"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => + Underlying.Value!.MetalGetLayer(view); - [NativeTypeName("#define SDL_PROP_WINDOW_HDR_HEADROOM_FLOAT \"SDL.window.HDR_headroom\"")] - public static Utf8String PropWindowHdrHeadroomFloat => "SDL.window.HDR_headroom"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) + { + fixed (void* __dsl_view = view) + { + return (void*)MetalGetLayer(__dsl_view); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_ANDROID_WINDOW_POINTER \"SDL.window.android.window\"")] - public static Utf8String PropWindowAndroidWindowPointer => "SDL.window.android.window"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool MinimizeWindow(WindowHandle window) => + Underlying.Value!.MinimizeWindow(window); - [NativeTypeName( - "#define SDL_PROP_WINDOW_ANDROID_SURFACE_POINTER \"SDL.window.android.surface\"" - )] - public static Utf8String PropWindowAndroidSurfacePointer => "SDL.window.android.surface"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte MinimizeWindowRaw(WindowHandle window) => + Underlying.Value!.MinimizeWindowRaw(window); - [NativeTypeName("#define SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER \"SDL.window.uikit.window\"")] - public static Utf8String PropWindowUikitWindowPointer => "SDL.window.uikit.window"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte MixAudio( + [NativeTypeName("Uint8 *")] byte* dst, + [NativeTypeName("const Uint8 *")] byte* src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) => Underlying.Value!.MixAudio(dst, src, format, len, volume); - [NativeTypeName( - "#define SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER \"SDL.window.uikit.metal_view_tag\"" - )] - public static Utf8String PropWindowUikitMetalViewTagNumber => - "SDL.window.uikit.metal_view_tag"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool MixAudio( + [NativeTypeName("Uint8 *")] Ref dst, + [NativeTypeName("const Uint8 *")] Ref src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) + { + fixed (byte* __dsl_src = src) + fixed (byte* __dsl_dst = dst) + { + return (MaybeBool)(byte)MixAudio(__dsl_dst, __dsl_src, format, len, volume); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_UIKIT_OPENGL_FRAMEBUFFER_NUMBER \"SDL.window.uikit.opengl.framebuffer\"" - )] - public static Utf8String PropWindowUikitOpenglFramebufferNumber => - "SDL.window.uikit.opengl.framebuffer"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Modf(double x, double* y) => Underlying.Value!.Modf(x, y); - [NativeTypeName( - "#define SDL_PROP_WINDOW_UIKIT_OPENGL_RENDERBUFFER_NUMBER \"SDL.window.uikit.opengl.renderbuffer\"" - )] - public static Utf8String PropWindowUikitOpenglRenderbufferNumber => - "SDL.window.uikit.opengl.renderbuffer"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Modf(double x, Ref y) + { + fixed (double* __dsl_y = y) + { + return (double)Modf(x, __dsl_y); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_UIKIT_OPENGL_RESOLVE_FRAMEBUFFER_NUMBER \"SDL.window.uikit.opengl.resolve_framebuffer\"" - )] - public static Utf8String PropWindowUikitOpenglResolveFramebufferNumber => - "SDL.window.uikit.opengl.resolve_framebuffer"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Modff(float x, float* y) => Underlying.Value!.Modff(x, y); - [NativeTypeName( - "#define SDL_PROP_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER \"SDL.window.kmsdrm.dev_index\"" - )] - public static Utf8String PropWindowKmsdrmDeviceIndexNumber => "SDL.window.kmsdrm.dev_index"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Modff(float x, Ref y) + { + fixed (float* __dsl_y = y) + { + return (float)Modff(x, __dsl_y); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_KMSDRM_DRM_FD_NUMBER \"SDL.window.kmsdrm.drm_fd\"")] - public static Utf8String PropWindowKmsdrmDrmFdNumber => "SDL.window.kmsdrm.drm_fd"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) => Underlying.Value!.Murmur3X32(data, len, seed); - [NativeTypeName( - "#define SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER \"SDL.window.kmsdrm.gbm_dev\"" - )] - public static Utf8String PropWindowKmsdrmGbmDevicePointer => "SDL.window.kmsdrm.gbm_dev"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) + { + fixed (void* __dsl_data = data) + { + return (uint)Murmur3X32(__dsl_data, len, seed); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_COCOA_WINDOW_POINTER \"SDL.window.cocoa.window\"")] - public static Utf8String PropWindowCocoaWindowPointer => "SDL.window.cocoa.window"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationDidEnterBackground() => + Underlying.Value!.OnApplicationDidEnterBackground(); - [NativeTypeName( - "#define SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER \"SDL.window.cocoa.metal_view_tag\"" - )] - public static Utf8String PropWindowCocoaMetalViewTagNumber => - "SDL.window.cocoa.metal_view_tag"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationDidEnterForeground() => + Underlying.Value!.OnApplicationDidEnterForeground(); - [NativeTypeName("#define SDL_PROP_WINDOW_OPENVR_OVERLAY_ID \"SDL.window.openvr.overlay_id\"")] - public static Utf8String PropWindowOpenvrOverlayId => "SDL.window.openvr.overlay_id"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationDidReceiveMemoryWarning() => + Underlying.Value!.OnApplicationDidReceiveMemoryWarning(); - [NativeTypeName( - "#define SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER \"SDL.window.vivante.display\"" - )] - public static Utf8String PropWindowVivanteDisplayPointer => "SDL.window.vivante.display"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationWillEnterBackground() => + Underlying.Value!.OnApplicationWillEnterBackground(); - [NativeTypeName("#define SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER \"SDL.window.vivante.window\"")] - public static Utf8String PropWindowVivanteWindowPointer => "SDL.window.vivante.window"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationWillEnterForeground() => + Underlying.Value!.OnApplicationWillEnterForeground(); - [NativeTypeName( - "#define SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER \"SDL.window.vivante.surface\"" - )] - public static Utf8String PropWindowVivanteSurfacePointer => "SDL.window.vivante.surface"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void OnApplicationWillTerminate() => + Underlying.Value!.OnApplicationWillTerminate(); - [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_HWND_POINTER \"SDL.window.win32.hwnd\"")] - public static Utf8String PropWindowWin32HwndPointer => "SDL.window.win32.hwnd"u8; + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec + ) => Underlying.Value!.OpenAudioDevice(devid, spec); - [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_HDC_POINTER \"SDL.window.win32.hdc\"")] - public static Utf8String PropWindowWin32HdcPointer => "SDL.window.win32.hdc"u8; + [return: NativeTypeName("SDL_AudioDeviceID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec + ) + { + fixed (AudioSpec* __dsl_spec = spec) + { + return (uint)OpenAudioDevice(devid, __dsl_spec); + } + } - [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER \"SDL.window.win32.instance\"")] - public static Utf8String PropWindowWin32InstancePointer => "SDL.window.win32.instance"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => Underlying.Value!.OpenAudioDeviceStream(devid, spec, callback, userdata); - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER \"SDL.window.wayland.display\"" - )] - public static Utf8String PropWindowWaylandDisplayPointer => "SDL.window.wayland.display"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (AudioSpec* __dsl_spec = spec) + { + return (AudioStreamHandle)OpenAudioDeviceStream( + devid, + __dsl_spec, + callback, + __dsl_userdata + ); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER \"SDL.window.wayland.surface\"" - )] - public static Utf8String PropWindowWaylandSurfacePointer => "SDL.window.wayland.surface"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec + ) => Underlying.Value!.OpenCamera(instance_id, spec); - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_EGL_WINDOW_POINTER \"SDL.window.wayland.egl_window\"" - )] - public static Utf8String PropWindowWaylandEglWindowPointer => "SDL.window.wayland.egl_window"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] Ref spec + ) + { + fixed (CameraSpec* __dsl_spec = spec) + { + return (CameraHandle)OpenCamera(instance_id, __dsl_spec); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_XDG_SURFACE_POINTER \"SDL.window.wayland.xdg_surface\"" - )] - public static Utf8String PropWindowWaylandXdgSurfacePointer => - "SDL.window.wayland.xdg_surface"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.OpenFileStorage(path); - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER \"SDL.window.wayland.xdg_toplevel\"" - )] - public static Utf8String PropWindowWaylandXdgToplevelPointer => - "SDL.window.wayland.xdg_toplevel"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenFileStorage( + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (StorageHandle)OpenFileStorage(__dsl_path); + } + } - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING \"SDL.window.wayland.xdg_toplevel_export_handle\"" - )] - public static Utf8String PropWindowWaylandXdgToplevelExportHandleString => - "SDL.window.wayland.xdg_toplevel_export_handle"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GamepadHandle OpenGamepad( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.OpenGamepad(instance_id); - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_XDG_POPUP_POINTER \"SDL.window.wayland.xdg_popup\"" - )] - public static Utf8String PropWindowWaylandXdgPopupPointer => "SDL.window.wayland.xdg_popup"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => + Underlying.Value!.OpenHaptic(instance_id); - [NativeTypeName( - "#define SDL_PROP_WINDOW_WAYLAND_XDG_POSITIONER_POINTER \"SDL.window.wayland.xdg_positioner\"" - )] - public static Utf8String PropWindowWaylandXdgPositionerPointer => - "SDL.window.wayland.xdg_positioner"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => + Underlying.Value!.OpenHapticFromJoystick(joystick); - [NativeTypeName("#define SDL_PROP_WINDOW_X11_DISPLAY_POINTER \"SDL.window.x11.display\"")] - public static Utf8String PropWindowX11DisplayPointer => "SDL.window.x11.display"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static HapticHandle OpenHapticFromMouse() => Underlying.Value!.OpenHapticFromMouse(); - [NativeTypeName("#define SDL_PROP_WINDOW_X11_SCREEN_NUMBER \"SDL.window.x11.screen\"")] - public static Utf8String PropWindowX11ScreenNumber => "SDL.window.x11.screen"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, + void* userdata + ) => Underlying.Value!.OpenIO(iface, userdata); - [NativeTypeName("#define SDL_PROP_WINDOW_X11_WINDOW_NUMBER \"SDL.window.x11.window\"")] - public static Utf8String PropWindowX11WindowNumber => "SDL.window.x11.window"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (IOStreamInterface* __dsl_iface = iface) + { + return (IOStreamHandle)OpenIO(__dsl_iface, __dsl_userdata); + } + } - [NativeTypeName("#define SDL_WINDOW_SURFACE_VSYNC_DISABLED 0")] - public const int WindowSurfaceVsyncDisabled = 0; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static JoystickHandle OpenJoystick( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => Underlying.Value!.OpenJoystick(instance_id); - [NativeTypeName("#define SDL_WINDOW_SURFACE_VSYNC_ADAPTIVE (-1)")] - public const int WindowSurfaceVsyncAdaptive = (-1); + [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => + Underlying.Value!.OpenSensor(instance_id); - [NativeTypeName("#define SDL_STANDARD_GRAVITY 9.80665f")] - public const float StandardGravity = 9.80665f; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, + void* userdata + ) => Underlying.Value!.OpenStorage(iface, userdata); - [NativeTypeName("#define SDL_JOYSTICK_AXIS_MAX 32767")] - public const int JoystickAxisMax = 32767; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] Ref iface, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (StorageInterface* __dsl_iface = iface) + { + return (StorageHandle)OpenStorage(__dsl_iface, __dsl_userdata); + } + } - [NativeTypeName("#define SDL_JOYSTICK_AXIS_MIN -32768")] - public const int JoystickAxisMin = -32768; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] sbyte* @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.OpenTitleStorage(@override, props); - [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN \"SDL.joystick.cap.mono_led\"")] - public static Utf8String PropJoystickCapMonoLedBoolean => "SDL.joystick.cap.mono_led"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] Ref @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) + { + fixed (sbyte* __dsl_override = @override) + { + return (StorageHandle)OpenTitleStorage(__dsl_override, props); + } + } - [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN \"SDL.joystick.cap.rgb_led\"")] - public static Utf8String PropJoystickCapRgbLedBoolean => "SDL.joystick.cap.rgb_led"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte OpenURL([NativeTypeName("const char *")] sbyte* url) => + Underlying.Value!.OpenURL(url); - [NativeTypeName( - "#define SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN \"SDL.joystick.cap.player_led\"" - )] - public static Utf8String PropJoystickCapPlayerLedBoolean => "SDL.joystick.cap.player_led"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) + { + fixed (sbyte* __dsl_url = url) + { + return (MaybeBool)(byte)OpenURL(__dsl_url); + } + } - [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN \"SDL.joystick.cap.rumble\"")] - public static Utf8String PropJoystickCapRumbleBoolean => "SDL.joystick.cap.rumble"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.OpenUserStorage(org, app, props); - [NativeTypeName( - "#define SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN \"SDL.joystick.cap.trigger_rumble\"" - )] - public static Utf8String PropJoystickCapTriggerRumbleBoolean => - "SDL.joystick.cap.trigger_rumble"u8; - - [NativeTypeName("#define SDL_HAT_CENTERED 0x00u")] - public const uint HatCentered = 0x00U; - - [NativeTypeName("#define SDL_HAT_UP 0x01u")] - public const uint HatUp = 0x01U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) + { + fixed (sbyte* __dsl_app = app) + fixed (sbyte* __dsl_org = org) + { + return (StorageHandle)OpenUserStorage(__dsl_org, __dsl_app, props); + } + } - [NativeTypeName("#define SDL_HAT_RIGHT 0x02u")] - public const uint HatRight = 0x02U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool OutOfMemory() => Underlying.Value!.OutOfMemory(); - [NativeTypeName("#define SDL_HAT_DOWN 0x04u")] - public const uint HatDown = 0x04U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte OutOfMemoryRaw() => Underlying.Value!.OutOfMemoryRaw(); - [NativeTypeName("#define SDL_HAT_LEFT 0x08u")] - public const uint HatLeft = 0x08U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PauseAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => Underlying.Value!.PauseAudioDevice(dev); - [NativeTypeName("#define SDL_HAT_RIGHTUP (SDL_HAT_RIGHT|SDL_HAT_UP)")] - public const uint HatRightup = (0x02U | 0x01U); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + Underlying.Value!.PauseAudioDeviceRaw(dev); - [NativeTypeName("#define SDL_HAT_RIGHTDOWN (SDL_HAT_RIGHT|SDL_HAT_DOWN)")] - public const uint HatRightdown = (0x02U | 0x04U); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => + Underlying.Value!.PauseAudioStreamDevice(stream); - [NativeTypeName("#define SDL_HAT_LEFTUP (SDL_HAT_LEFT|SDL_HAT_UP)")] - public const uint HatLeftup = (0x08U | 0x01U); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => + Underlying.Value!.PauseAudioStreamDeviceRaw(stream); - [NativeTypeName("#define SDL_HAT_LEFTDOWN (SDL_HAT_LEFT|SDL_HAT_DOWN)")] - public const uint HatLeftdown = (0x08U | 0x04U); + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PauseHaptic(HapticHandle haptic) => + Underlying.Value!.PauseHaptic(haptic); - [NativeTypeName( - "#define SDL_PROP_GAMEPAD_CAP_MONO_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN" - )] - public static Utf8String PropGamepadCapMonoLedBoolean => "SDL.joystick.cap.mono_led"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PauseHapticRaw(HapticHandle haptic) => + Underlying.Value!.PauseHapticRaw(haptic); - [NativeTypeName( - "#define SDL_PROP_GAMEPAD_CAP_RGB_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN" - )] - public static Utf8String PropGamepadCapRgbLedBoolean => "SDL.joystick.cap.rgb_led"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int PeepEvents( + Event* events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => Underlying.Value!.PeepEvents(events, numevents, action, minType, maxType); - [NativeTypeName( - "#define SDL_PROP_GAMEPAD_CAP_PLAYER_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN" - )] - public static Utf8String PropGamepadCapPlayerLedBoolean => "SDL.joystick.cap.player_led"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int PeepEvents( + Ref events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) + { + fixed (Event* __dsl_events = events) + { + return (int)PeepEvents(__dsl_events, numevents, action, minType, maxType); + } + } - [NativeTypeName( - "#define SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN" - )] - public static Utf8String PropGamepadCapRumbleBoolean => "SDL.joystick.cap.rumble"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PlayHapticRumble( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => Underlying.Value!.PlayHapticRumble(haptic, strength, length); - [NativeTypeName( - "#define SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN" - )] - public static Utf8String PropGamepadCapTriggerRumbleBoolean => - "SDL.joystick.cap.trigger_rumble"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PlayHapticRumbleRaw( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => Underlying.Value!.PlayHapticRumbleRaw(haptic, strength, length); - [NativeTypeName("#define SDLK_SCANCODE_MASK (1u<<30)")] - public const uint KScancodeMask = (1U << 30); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PollEvent(Event* @event) => Underlying.Value!.PollEvent(@event); - [NativeTypeName("#define SDLK_UNKNOWN 0x00000000u")] - public const uint KUnknown = 0x00000000U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PollEvent(Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)PollEvent(__dsl_event); + } + } - [NativeTypeName("#define SDLK_RETURN 0x0000000du")] - public const uint KReturn = 0x0000000dU; + [NativeFunction("SDL3", EntryPoint = "SDL_PopGPUDebugGroup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer) => + Underlying.Value!.PopGPUDebugGroup(command_buffer); - [NativeTypeName("#define SDLK_ESCAPE 0x0000001bu")] - public const uint KEscape = 0x0000001bU; + [NativeFunction("SDL3", EntryPoint = "SDL_pow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Pow(double x, double y) => Underlying.Value!.Pow(x, y); - [NativeTypeName("#define SDLK_BACKSPACE 0x00000008u")] - public const uint KBackspace = 0x00000008U; + [NativeFunction("SDL3", EntryPoint = "SDL_powf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Powf(float x, float y) => Underlying.Value!.Powf(x, y); - [NativeTypeName("#define SDLK_TAB 0x00000009u")] - public const uint KTab = 0x00000009U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch, + [NativeTypeName("bool")] byte linear + ) => + Underlying.Value!.PremultiplyAlpha( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch, + linear + ); - [NativeTypeName("#define SDLK_SPACE 0x00000020u")] - public const uint KSpace = 0x00000020U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch, + [NativeTypeName("bool")] MaybeBool linear + ) + { + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) + { + return (MaybeBool) + (byte)PremultiplyAlpha( + width, + height, + src_format, + __dsl_src, + src_pitch, + dst_format, + __dsl_dst, + dst_pitch, + (byte)linear + ); + } + } - [NativeTypeName("#define SDLK_EXCLAIM 0x00000021u")] - public const uint KExclaim = 0x00000021U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PremultiplySurfaceAlpha( + Surface* surface, + [NativeTypeName("bool")] byte linear + ) => Underlying.Value!.PremultiplySurfaceAlpha(surface, linear); - [NativeTypeName("#define SDLK_DBLAPOSTROPHE 0x00000022u")] - public const uint KDblapostrophe = 0x00000022U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PremultiplySurfaceAlpha( + Ref surface, + [NativeTypeName("bool")] MaybeBool linear + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)PremultiplySurfaceAlpha(__dsl_surface, (byte)linear); + } + } - [NativeTypeName("#define SDLK_HASH 0x00000023u")] - public const uint KHash = 0x00000023U; + [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PumpEvents() => Underlying.Value!.PumpEvents(); - [NativeTypeName("#define SDLK_DOLLAR 0x00000024u")] - public const uint KDollar = 0x00000024U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PushEvent(Event* @event) => Underlying.Value!.PushEvent(@event); - [NativeTypeName("#define SDLK_PERCENT 0x00000025u")] - public const uint KPercent = 0x00000025U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PushEvent(Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)PushEvent(__dsl_event); + } + } - [NativeTypeName("#define SDLK_AMPERSAND 0x00000026u")] - public const uint KAmpersand = 0x00000026U; + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => Underlying.Value!.PushGPUComputeUniformData(command_buffer, slot_index, data, length); - [NativeTypeName("#define SDLK_APOSTROPHE 0x00000027u")] - public const uint KApostrophe = 0x00000027U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUComputeUniformData(command_buffer, slot_index, __dsl_data, length); + } + } - [NativeTypeName("#define SDLK_LEFTPAREN 0x00000028u")] - public const uint KLeftparen = 0x00000028U; + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.PushGPUDebugGroup(command_buffer, name); - [NativeTypeName("#define SDLK_RIGHTPAREN 0x00000029u")] - public const uint KRightparen = 0x00000029U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + PushGPUDebugGroup(command_buffer, __dsl_name); + } + } - [NativeTypeName("#define SDLK_ASTERISK 0x0000002au")] - public const uint KAsterisk = 0x0000002aU; + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => Underlying.Value!.PushGPUFragmentUniformData(command_buffer, slot_index, data, length); - [NativeTypeName("#define SDLK_PLUS 0x0000002bu")] - public const uint KPlus = 0x0000002bU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUFragmentUniformData(command_buffer, slot_index, __dsl_data, length); + } + } - [NativeTypeName("#define SDLK_COMMA 0x0000002cu")] - public const uint KComma = 0x0000002cU; + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => Underlying.Value!.PushGPUVertexUniformData(command_buffer, slot_index, data, length); - [NativeTypeName("#define SDLK_MINUS 0x0000002du")] - public const uint KMinus = 0x0000002dU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + PushGPUVertexUniformData(command_buffer, slot_index, __dsl_data, length); + } + } - [NativeTypeName("#define SDLK_PERIOD 0x0000002eu")] - public const uint KPeriod = 0x0000002eU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] void* buf, + int len + ) => Underlying.Value!.PutAudioStreamData(stream, buf, len); - [NativeTypeName("#define SDLK_SLASH 0x0000002fu")] - public const uint KSlash = 0x0000002fU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] Ref buf, + int len + ) + { + fixed (void* __dsl_buf = buf) + { + return (MaybeBool)(byte)PutAudioStreamData(stream, __dsl_buf, len); + } + } - [NativeTypeName("#define SDLK_0 0x00000030u")] - public const uint K0 = 0x00000030U; + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => Underlying.Value!.Qsort(@base, nmemb, size, compare); - [NativeTypeName("#define SDLK_1 0x00000031u")] - public const uint K1 = 0x00000031U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) + { + fixed (void* __dsl_base = @base) + { + Qsort(__dsl_base, nmemb, size, compare); + } + } - [NativeTypeName("#define SDLK_2 0x00000032u")] - public const uint K2 = 0x00000032U; + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => Underlying.Value!.QsortR(@base, nmemb, size, compare, userdata); - [NativeTypeName("#define SDLK_3 0x00000033u")] - public const uint K3 = 0x00000033U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) + { + QsortR(__dsl_base, nmemb, size, compare, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_4 0x00000034u")] - public const uint K4 = 0x00000034U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + Underlying.Value!.QueryGPUFence(device, fence); - [NativeTypeName("#define SDLK_5 0x00000035u")] - public const uint K5 = 0x00000035U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence) => + Underlying.Value!.QueryGPUFenceRaw(device, fence); - [NativeTypeName("#define SDLK_6 0x00000036u")] - public const uint K6 = 0x00000036U; + [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Quit() => Underlying.Value!.Quit(); - [NativeTypeName("#define SDLK_7 0x00000037u")] - public const uint K7 = 0x00000037U; + [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.QuitSubSystem(flags); - [NativeTypeName("#define SDLK_8 0x00000038u")] - public const uint K8 = 0x00000038U; - - [NativeTypeName("#define SDLK_9 0x00000039u")] - public const uint K9 = 0x00000039U; - - [NativeTypeName("#define SDLK_COLON 0x0000003au")] - public const uint KColon = 0x0000003aU; - - [NativeTypeName("#define SDLK_SEMICOLON 0x0000003bu")] - public const uint KSemicolon = 0x0000003bU; - - [NativeTypeName("#define SDLK_LESS 0x0000003cu")] - public const uint KLess = 0x0000003cU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RaiseWindow(WindowHandle window) => + Underlying.Value!.RaiseWindow(window); - [NativeTypeName("#define SDLK_EQUALS 0x0000003du")] - public const uint KEquals = 0x0000003dU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RaiseWindowRaw(WindowHandle window) => + Underlying.Value!.RaiseWindowRaw(window); - [NativeTypeName("#define SDLK_GREATER 0x0000003eu")] - public const uint KGreater = 0x0000003eU; + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Rand([NativeTypeName("Sint32")] int n) => Underlying.Value!.Rand(n); - [NativeTypeName("#define SDLK_QUESTION 0x0000003fu")] - public const uint KQuestion = 0x0000003fU; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint RandBits() => Underlying.Value!.RandBits(); - [NativeTypeName("#define SDLK_AT 0x00000040u")] - public const uint KAt = 0x00000040U; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state) => + Underlying.Value!.RandBitsR(state); - [NativeTypeName("#define SDLK_LEFTBRACKET 0x0000005bu")] - public const uint KLeftbracket = 0x0000005bU; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint RandBitsR([NativeTypeName("Uint64 *")] Ref state) + { + fixed (ulong* __dsl_state = state) + { + return (uint)RandBitsR(__dsl_state); + } + } - [NativeTypeName("#define SDLK_BACKSLASH 0x0000005cu")] - public const uint KBackslash = 0x0000005cU; + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RandR( + [NativeTypeName("Uint64 *")] ulong* state, + [NativeTypeName("Sint32")] int n + ) => Underlying.Value!.RandR(state, n); - [NativeTypeName("#define SDLK_RIGHTBRACKET 0x0000005du")] - public const uint KRightbracket = 0x0000005dU; + [return: NativeTypeName("Sint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RandR( + [NativeTypeName("Uint64 *")] Ref state, + [NativeTypeName("Sint32")] int n + ) + { + fixed (ulong* __dsl_state = state) + { + return (int)RandR(__dsl_state, n); + } + } - [NativeTypeName("#define SDLK_CARET 0x0000005eu")] - public const uint KCaret = 0x0000005eU; + [NativeFunction("SDL3", EntryPoint = "SDL_randf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Randf() => Underlying.Value!.Randf(); - [NativeTypeName("#define SDLK_UNDERSCORE 0x0000005fu")] - public const uint KUnderscore = 0x0000005fU; + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float RandfR([NativeTypeName("Uint64 *")] ulong* state) => + Underlying.Value!.RandfR(state); - [NativeTypeName("#define SDLK_GRAVE 0x00000060u")] - public const uint KGrave = 0x00000060U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float RandfR([NativeTypeName("Uint64 *")] Ref state) + { + fixed (ulong* __dsl_state = state) + { + return (float)RandfR(__dsl_state); + } + } - [NativeTypeName("#define SDLK_A 0x00000061u")] - public const uint Ka = 0x00000061U; + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint ReadIO( + IOStreamHandle context, + void* ptr, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.ReadIO(context, ptr, size); - [NativeTypeName("#define SDLK_B 0x00000062u")] - public const uint Kb = 0x00000062U; + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint ReadIO( + IOStreamHandle context, + Ref ptr, + [NativeTypeName("size_t")] nuint size + ) + { + fixed (void* __dsl_ptr = ptr) + { + return (nuint)ReadIO(context, __dsl_ptr, size); + } + } - [NativeTypeName("#define SDLK_C 0x00000063u")] - public const uint Kc = 0x00000063U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ) => Underlying.Value!.ReadProcess(process, datasize, exitcode); - [NativeTypeName("#define SDLK_D 0x00000064u")] - public const uint Kd = 0x00000064U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ) + { + fixed (int* __dsl_exitcode = exitcode) + fixed (nuint* __dsl_datasize = datasize) + { + return (void*)ReadProcess(process, __dsl_datasize, __dsl_exitcode); + } + } - [NativeTypeName("#define SDLK_E 0x00000065u")] - public const uint Ke = 0x00000065U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS16BE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] short* value + ) => Underlying.Value!.ReadS16BE(src, value); - [NativeTypeName("#define SDLK_F 0x00000066u")] - public const uint Kf = 0x00000066U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS16BE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) + { + fixed (short* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS16BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_G 0x00000067u")] - public const uint Kg = 0x00000067U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS16LE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] short* value + ) => Underlying.Value!.ReadS16LE(src, value); - [NativeTypeName("#define SDLK_H 0x00000068u")] - public const uint Kh = 0x00000068U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS16LE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) + { + fixed (short* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS16LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_I 0x00000069u")] - public const uint Ki = 0x00000069U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + Underlying.Value!.ReadS32BE(src, value); - [NativeTypeName("#define SDLK_J 0x0000006au")] - public const uint Kj = 0x0000006aU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS32BE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) + { + fixed (int* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS32BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_K 0x0000006bu")] - public const uint Kk = 0x0000006bU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + Underlying.Value!.ReadS32LE(src, value); - [NativeTypeName("#define SDLK_L 0x0000006cu")] - public const uint Kl = 0x0000006cU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS32LE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) + { + fixed (int* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS32LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_M 0x0000006du")] - public const uint Km = 0x0000006dU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS64BE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] long* value + ) => Underlying.Value!.ReadS64BE(src, value); - [NativeTypeName("#define SDLK_N 0x0000006eu")] - public const uint Kn = 0x0000006eU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS64BE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) + { + fixed (long* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS64BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_O 0x0000006fu")] - public const uint Ko = 0x0000006fU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS64LE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] long* value + ) => Underlying.Value!.ReadS64LE(src, value); - [NativeTypeName("#define SDLK_P 0x00000070u")] - public const uint Kp = 0x00000070U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS64LE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) + { + fixed (long* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS64LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_Q 0x00000071u")] - public const uint Kq = 0x00000071U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => + Underlying.Value!.ReadS8(src, value); - [NativeTypeName("#define SDLK_R 0x00000072u")] - public const uint Kr = 0x00000072U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadS8( + IOStreamHandle src, + [NativeTypeName("Sint8 *")] Ref value + ) + { + fixed (sbyte* __dsl_value = value) + { + return (MaybeBool)(byte)ReadS8(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_S 0x00000073u")] - public const uint Ks = 0x00000073U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + void* destination, + [NativeTypeName("Uint64")] ulong length + ) => Underlying.Value!.ReadStorageFile(storage, path, destination, length); - [NativeTypeName("#define SDLK_T 0x00000074u")] - public const uint Kt = 0x00000074U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref destination, + [NativeTypeName("Uint64")] ulong length + ) + { + fixed (void* __dsl_destination = destination) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)ReadStorageFile(storage, __dsl_path, __dsl_destination, length); + } + } - [NativeTypeName("#define SDLK_U 0x00000075u")] - public const uint Ku = 0x00000075U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => Underlying.Value!.ReadSurfacePixel(surface, x, y, r, g, b, a); - [NativeTypeName("#define SDLK_V 0x00000076u")] - public const uint Kv = 0x00000076U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) + { + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)ReadSurfacePixel(__dsl_surface, x, y, __dsl_r, __dsl_g, __dsl_b, __dsl_a); + } + } - [NativeTypeName("#define SDLK_W 0x00000077u")] - public const uint Kw = 0x00000077U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadSurfacePixelFloat( + Surface* surface, + int x, + int y, + float* r, + float* g, + float* b, + float* a + ) => Underlying.Value!.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); - [NativeTypeName("#define SDLK_X 0x00000078u")] - public const uint Kx = 0x00000078U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadSurfacePixelFloat( + Ref surface, + int x, + int y, + Ref r, + Ref g, + Ref b, + Ref a + ) + { + fixed (float* __dsl_a = a) + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)ReadSurfacePixelFloat( + __dsl_surface, + x, + y, + __dsl_r, + __dsl_g, + __dsl_b, + __dsl_a + ); + } + } - [NativeTypeName("#define SDLK_Y 0x00000079u")] - public const uint Ky = 0x00000079U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU16BE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] ushort* value + ) => Underlying.Value!.ReadU16BE(src, value); - [NativeTypeName("#define SDLK_Z 0x0000007au")] - public const uint Kz = 0x0000007aU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU16BE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) + { + fixed (ushort* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU16BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_LEFTBRACE 0x0000007bu")] - public const uint KLeftbrace = 0x0000007bU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU16LE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] ushort* value + ) => Underlying.Value!.ReadU16LE(src, value); - [NativeTypeName("#define SDLK_PIPE 0x0000007cu")] - public const uint KPipe = 0x0000007cU; - - [NativeTypeName("#define SDLK_RIGHTBRACE 0x0000007du")] - public const uint KRightbrace = 0x0000007dU; - - [NativeTypeName("#define SDLK_TILDE 0x0000007eu")] - public const uint KTilde = 0x0000007eU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU16LE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) + { + fixed (ushort* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU16LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_DELETE 0x0000007fu")] - public const uint KDelete = 0x0000007fU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU32BE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] uint* value + ) => Underlying.Value!.ReadU32BE(src, value); - [NativeTypeName("#define SDLK_PLUSMINUS 0x000000b1u")] - public const uint KPlusminus = 0x000000b1U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU32BE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) + { + fixed (uint* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU32BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_CAPSLOCK 0x40000039u")] - public const uint KCapslock = 0x40000039U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU32LE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] uint* value + ) => Underlying.Value!.ReadU32LE(src, value); - [NativeTypeName("#define SDLK_F1 0x4000003au")] - public const uint KF1 = 0x4000003aU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU32LE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) + { + fixed (uint* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU32LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_F2 0x4000003bu")] - public const uint KF2 = 0x4000003bU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU64BE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] ulong* value + ) => Underlying.Value!.ReadU64BE(src, value); - [NativeTypeName("#define SDLK_F3 0x4000003cu")] - public const uint KF3 = 0x4000003cU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU64BE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) + { + fixed (ulong* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU64BE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_F4 0x4000003du")] - public const uint KF4 = 0x4000003dU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU64LE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] ulong* value + ) => Underlying.Value!.ReadU64LE(src, value); - [NativeTypeName("#define SDLK_F5 0x4000003eu")] - public const uint KF5 = 0x4000003eU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU64LE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) + { + fixed (ulong* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU64LE(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_F6 0x4000003fu")] - public const uint KF6 = 0x4000003fU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => + Underlying.Value!.ReadU8(src, value); - [NativeTypeName("#define SDLK_F7 0x40000040u")] - public const uint KF7 = 0x40000040U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReadU8( + IOStreamHandle src, + [NativeTypeName("Uint8 *")] Ref value + ) + { + fixed (byte* __dsl_value = value) + { + return (MaybeBool)(byte)ReadU8(src, __dsl_value); + } + } - [NativeTypeName("#define SDLK_F8 0x40000041u")] - public const uint KF8 = 0x40000041U; + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size) => + Underlying.Value!.Realloc(mem, size); - [NativeTypeName("#define SDLK_F9 0x40000042u")] - public const uint KF9 = 0x40000042U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size) + { + fixed (void* __dsl_mem = mem) + { + return (void*)Realloc(__dsl_mem, size); + } + } - [NativeTypeName("#define SDLK_F10 0x40000043u")] - public const uint KF10 = 0x40000043U; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint RegisterEvents(int numevents) => + Underlying.Value!.RegisterEvents(numevents); - [NativeTypeName("#define SDLK_F11 0x40000044u")] - public const uint KF11 = 0x40000044U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => + Underlying.Value!.ReleaseCameraFrame(camera, frame); - [NativeTypeName("#define SDLK_F12 0x40000045u")] - public const uint KF12 = 0x40000045U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseCameraFrame(CameraHandle camera, Ref frame) + { + fixed (Surface* __dsl_frame = frame) + { + ReleaseCameraFrame(camera, __dsl_frame); + } + } - [NativeTypeName("#define SDLK_PRINTSCREEN 0x40000046u")] - public const uint KPrintscreen = 0x40000046U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer) => + Underlying.Value!.ReleaseGPUBuffer(device, buffer); - [NativeTypeName("#define SDLK_SCROLLLOCK 0x40000047u")] - public const uint KScrolllock = 0x40000047U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUComputePipeline")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ) => Underlying.Value!.ReleaseGPUComputePipeline(device, compute_pipeline); - [NativeTypeName("#define SDLK_PAUSE 0x40000048u")] - public const uint KPause = 0x40000048U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUFence")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + Underlying.Value!.ReleaseGPUFence(device, fence); - [NativeTypeName("#define SDLK_INSERT 0x40000049u")] - public const uint KInsert = 0x40000049U; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ) => Underlying.Value!.ReleaseGPUGraphicsPipeline(device, graphics_pipeline); - [NativeTypeName("#define SDLK_HOME 0x4000004au")] - public const uint KHome = 0x4000004aU; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUSampler")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler) => + Underlying.Value!.ReleaseGPUSampler(device, sampler); - [NativeTypeName("#define SDLK_PAGEUP 0x4000004bu")] - public const uint KPageup = 0x4000004bU; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUShader")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader) => + Underlying.Value!.ReleaseGPUShader(device, shader); - [NativeTypeName("#define SDLK_END 0x4000004du")] - public const uint KEnd = 0x4000004dU; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture) => + Underlying.Value!.ReleaseGPUTexture(device, texture); - [NativeTypeName("#define SDLK_PAGEDOWN 0x4000004eu")] - public const uint KPagedown = 0x4000004eU; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => Underlying.Value!.ReleaseGPUTransferBuffer(device, transfer_buffer); - [NativeTypeName("#define SDLK_RIGHT 0x4000004fu")] - public const uint KRight = 0x4000004fU; + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ReleaseWindowFromGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ) => Underlying.Value!.ReleaseWindowFromGPUDevice(device, window); - [NativeTypeName("#define SDLK_LEFT 0x40000050u")] - public const uint KLeft = 0x40000050U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ReloadGamepadMappings() => + Underlying.Value!.ReloadGamepadMappings(); - [NativeTypeName("#define SDLK_DOWN 0x40000051u")] - public const uint KDown = 0x40000051U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ReloadGamepadMappingsRaw() => + Underlying.Value!.ReloadGamepadMappingsRaw(); - [NativeTypeName("#define SDLK_UP 0x40000052u")] - public const uint KUp = 0x40000052U; + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => Underlying.Value!.RemoveEventWatch(filter, userdata); - [NativeTypeName("#define SDLK_NUMLOCKCLEAR 0x40000053u")] - public const uint KNumlockclear = 0x40000053U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + RemoveEventWatch(filter, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_DIVIDE 0x40000054u")] - public const uint KKpDivide = 0x40000054U; + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => Underlying.Value!.RemoveHintCallback(name, callback, userdata); - [NativeTypeName("#define SDLK_KP_MULTIPLY 0x40000055u")] - public const uint KKpMultiply = 0x40000055U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_name = name) + { + RemoveHintCallback(__dsl_name, callback, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_MINUS 0x40000056u")] - public const uint KKpMinus = 0x40000056U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RemovePath([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.RemovePath(path); - [NativeTypeName("#define SDLK_KP_PLUS 0x40000057u")] - public const uint KKpPlus = 0x40000057U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)RemovePath(__dsl_path); + } + } - [NativeTypeName("#define SDLK_KP_ENTER 0x40000058u")] - public const uint KKpEnter = 0x40000058U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => Underlying.Value!.RemoveStoragePath(storage, path); - [NativeTypeName("#define SDLK_KP_1 0x40000059u")] - public const uint KKp1 = 0x40000059U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)RemoveStoragePath(storage, __dsl_path); + } + } - [NativeTypeName("#define SDLK_KP_2 0x4000005au")] - public const uint KKp2 = 0x4000005aU; + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveSurfaceAlternateImages(Surface* surface) => + Underlying.Value!.RemoveSurfaceAlternateImages(surface); - [NativeTypeName("#define SDLK_KP_3 0x4000005bu")] - public const uint KKp3 = 0x4000005bU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void RemoveSurfaceAlternateImages(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + RemoveSurfaceAlternateImages(__dsl_surface); + } + } - [NativeTypeName("#define SDLK_KP_4 0x4000005cu")] - public const uint KKp4 = 0x4000005cU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => + Underlying.Value!.RemoveTimer(id); - [NativeTypeName("#define SDLK_KP_5 0x4000005du")] - public const uint KKp5 = 0x4000005dU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => + Underlying.Value!.RemoveTimerRaw(id); - [NativeTypeName("#define SDLK_KP_6 0x4000005eu")] - public const uint KKp6 = 0x4000005eU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenamePath( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => Underlying.Value!.RenamePath(oldpath, newpath); - [NativeTypeName("#define SDLK_KP_7 0x4000005fu")] - public const uint KKp7 = 0x4000005fU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenamePath( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) + { + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) + { + return (MaybeBool)(byte)RenamePath(__dsl_oldpath, __dsl_newpath); + } + } - [NativeTypeName("#define SDLK_KP_8 0x40000060u")] - public const uint KKp8 = 0x40000060U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => Underlying.Value!.RenameStoragePath(storage, oldpath, newpath); - [NativeTypeName("#define SDLK_KP_9 0x40000061u")] - public const uint KKp9 = 0x40000061U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) + { + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) + { + return (MaybeBool) + (byte)RenameStoragePath(storage, __dsl_oldpath, __dsl_newpath); + } + } - [NativeTypeName("#define SDLK_KP_0 0x40000062u")] - public const uint KKp0 = 0x40000062U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderClear(RendererHandle renderer) => + Underlying.Value!.RenderClear(renderer); - [NativeTypeName("#define SDLK_KP_PERIOD 0x40000063u")] - public const uint KKpPeriod = 0x40000063U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderClearRaw(RendererHandle renderer) => + Underlying.Value!.RenderClearRaw(renderer); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderClipEnabled(RendererHandle renderer) => + Underlying.Value!.RenderClipEnabled(renderer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderClipEnabledRaw(RendererHandle renderer) => + Underlying.Value!.RenderClipEnabledRaw(renderer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + float* x, + float* y + ) => Underlying.Value!.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + Ref x, + Ref y + ) + { + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + { + return (MaybeBool) + (byte)RenderCoordinatesFromWindow( + renderer, + window_x, + window_y, + __dsl_x, + __dsl_y + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + float* window_x, + float* window_y + ) => Underlying.Value!.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + Ref window_x, + Ref window_y + ) + { + fixed (float* __dsl_window_y = window_y) + fixed (float* __dsl_window_x = window_x) + { + return (MaybeBool) + (byte)RenderCoordinatesToWindow(renderer, x, y, __dsl_window_x, __dsl_window_y); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] sbyte* str + ) => Underlying.Value!.RenderDebugText(renderer, x, y, str); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] Ref str + ) + { + fixed (sbyte* __dsl_str = str) + { + return (MaybeBool)(byte)RenderDebugText(renderer, x, y, __dsl_str); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => Underlying.Value!.RenderFillRect(renderer, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) + { + fixed (FRect* __dsl_rect = rect) + { + return (MaybeBool)(byte)RenderFillRect(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => Underlying.Value!.RenderFillRects(renderer, rects, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) + { + fixed (FRect* __dsl_rects = rects) + { + return (MaybeBool)(byte)RenderFillRects(renderer, __dsl_rects, count); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderGeometry( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, + int num_vertices, + [NativeTypeName("const int *")] int* indices, + int num_indices + ) => + Underlying.Value!.RenderGeometry( + renderer, + texture, + vertices, + num_vertices, + indices, + num_indices + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderGeometry( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_Vertex *")] Ref vertices, + int num_vertices, + [NativeTypeName("const int *")] Ref indices, + int num_indices + ) + { + fixed (int* __dsl_indices = indices) + fixed (Vertex* __dsl_vertices = vertices) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderGeometry( + renderer, + __dsl_texture, + __dsl_vertices, + num_vertices, + __dsl_indices, + num_indices + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderGeometryRaw( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const float *")] float* xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] FColor* color, + int color_stride, + [NativeTypeName("const float *")] float* uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] void* indices, + int num_indices, + int size_indices + ) => + Underlying.Value!.RenderGeometryRaw( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderGeometryRaw( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const float *")] Ref xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] Ref color, + int color_stride, + [NativeTypeName("const float *")] Ref uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] Ref indices, + int num_indices, + int size_indices + ) + { + fixed (void* __dsl_indices = indices) + fixed (float* __dsl_uv = uv) + fixed (FColor* __dsl_color = color) + fixed (float* __dsl_xy = xy) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderGeometryRaw( + renderer, + __dsl_texture, + __dsl_xy, + xy_stride, + __dsl_color, + color_stride, + __dsl_uv, + uv_stride, + num_vertices, + __dsl_indices, + num_indices, + size_indices + ); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderLine( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => Underlying.Value!.RenderLine(renderer, x1, y1, x2, y2); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderLineRaw( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => Underlying.Value!.RenderLineRaw(renderer, x1, y1, x2, y2); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => Underlying.Value!.RenderLines(renderer, points, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) + { + fixed (FPoint* __dsl_points = points) + { + return (MaybeBool)(byte)RenderLines(renderer, __dsl_points, count); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => + Underlying.Value!.RenderPoint(renderer, x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderPointRaw(RendererHandle renderer, float x, float y) => + Underlying.Value!.RenderPointRaw(renderer, x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => Underlying.Value!.RenderPoints(renderer, points, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) + { + fixed (FPoint* __dsl_points = points) + { + return (MaybeBool)(byte)RenderPoints(renderer, __dsl_points, count); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderPresent(RendererHandle renderer) => + Underlying.Value!.RenderPresent(renderer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderPresentRaw(RendererHandle renderer) => + Underlying.Value!.RenderPresentRaw(renderer); + + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Surface* RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => Underlying.Value!.RenderReadPixels(renderer, rect); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (Surface*)RenderReadPixels(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => Underlying.Value!.RenderRect(renderer, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) + { + fixed (FRect* __dsl_rect = rect) + { + return (MaybeBool)(byte)RenderRect(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => Underlying.Value!.RenderRects(renderer, rects, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) + { + fixed (FRect* __dsl_rects = rects) + { + return (MaybeBool)(byte)RenderRects(renderer, __dsl_rects, count); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderTexture( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => Underlying.Value!.RenderTexture(renderer, texture, srcrect, dstrect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderTexture( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) + { + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderTexture(renderer, __dsl_texture, __dsl_srcrect, __dsl_dstrect); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderTexture9Grid( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => + Underlying.Value!.RenderTexture9Grid( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderTexture9Grid( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) + { + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderTexture9Grid( + renderer, + __dsl_texture, + __dsl_srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + __dsl_dstrect + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderTextureRotated( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] FPoint* center, + FlipMode flip + ) => + Underlying.Value!.RenderTextureRotated( + renderer, + texture, + srcrect, + dstrect, + angle, + center, + flip + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderTextureRotated( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] Ref center, + FlipMode flip + ) + { + fixed (FPoint* __dsl_center = center) + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderTextureRotated( + renderer, + __dsl_texture, + __dsl_srcrect, + __dsl_dstrect, + angle, + __dsl_center, + flip + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderTextureTiled( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => Underlying.Value!.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderTextureTiled( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) + { + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)RenderTextureTiled( + renderer, + __dsl_texture, + __dsl_srcrect, + scale, + __dsl_dstrect + ); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RenderViewportSet(RendererHandle renderer) => + Underlying.Value!.RenderViewportSet(renderer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RenderViewportSetRaw(RendererHandle renderer) => + Underlying.Value!.RenderViewportSetRaw(renderer); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static AssertState ReportAssertion( + AssertData* data, + [NativeTypeName("const char *")] sbyte* func, + [NativeTypeName("const char *")] sbyte* file, + int line + ) => Underlying.Value!.ReportAssertion(data, func, file, line); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static AssertState ReportAssertion( + Ref data, + [NativeTypeName("const char *")] Ref func, + [NativeTypeName("const char *")] Ref file, + int line + ) + { + fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_func = func) + fixed (AssertData* __dsl_data = data) + { + return (AssertState)ReportAssertion(__dsl_data, __dsl_func, __dsl_file, line); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ResetAssertionReport() => Underlying.Value!.ResetAssertionReport(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ResetHint([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.ResetHint(name); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)ResetHint(__dsl_name); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ResetHints() => Underlying.Value!.ResetHints(); + + [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ResetKeyboard() => Underlying.Value!.ResetKeyboard(); + + [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ResetLogPriorities() => Underlying.Value!.ResetLogPriorities(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RestoreWindow(WindowHandle window) => + Underlying.Value!.RestoreWindow(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RestoreWindowRaw(WindowHandle window) => + Underlying.Value!.RestoreWindowRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ResumeAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => Underlying.Value!.ResumeAudioDevice(dev); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + Underlying.Value!.ResumeAudioDeviceRaw(dev); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => + Underlying.Value!.ResumeAudioStreamDevice(stream); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => + Underlying.Value!.ResumeAudioStreamDeviceRaw(stream); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ResumeHaptic(HapticHandle haptic) => + Underlying.Value!.ResumeHaptic(haptic); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ResumeHapticRaw(HapticHandle haptic) => + Underlying.Value!.ResumeHapticRaw(haptic); + + [NativeFunction("SDL3", EntryPoint = "SDL_round")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Round(double x) => Underlying.Value!.Round(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_roundf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Roundf(float x) => Underlying.Value!.Roundf(x); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RumbleGamepad( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleGamepad( + gamepad, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RumbleGamepadRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleGamepadRaw( + gamepad, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RumbleGamepadTriggers( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleGamepadTriggers( + gamepad, + left_rumble, + right_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RumbleGamepadTriggersRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleGamepadTriggersRaw( + gamepad, + left_rumble, + right_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RumbleJoystick( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleJoystick( + joystick, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RumbleJoystickRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleJoystickRaw( + joystick, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RumbleJoystickTriggers( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleJoystickTriggers( + joystick, + left_rumble, + right_rumble, + duration_ms + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RumbleJoystickTriggersRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + Underlying.Value!.RumbleJoystickTriggersRaw( + joystick, + left_rumble, + right_rumble, + duration_ms + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ) => Underlying.Value!.RunApp(argc, argv, mainFunction, reserved); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ) + { + fixed (void* __dsl_reserved = reserved) + fixed (sbyte** __dsl_argv = argv) + { + return (int)RunApp(argc, __dsl_argv, mainFunction, __dsl_reserved); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool RunHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => Underlying.Value!.RunHapticEffect(haptic, effect, iterations); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte RunHapticEffectRaw( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => Underlying.Value!.RunHapticEffectRaw(haptic, effect, iterations); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SaveBMP( + Surface* surface, + [NativeTypeName("const char *")] sbyte* file + ) => Underlying.Value!.SaveBMP(surface, file); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SaveBMP( + Ref surface, + [NativeTypeName("const char *")] Ref file + ) + { + fixed (sbyte* __dsl_file = file) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SaveBMP(__dsl_surface, __dsl_file); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SaveBMPIO( + Surface* surface, + IOStreamHandle dst, + [NativeTypeName("bool")] byte closeio + ) => Underlying.Value!.SaveBMPIO(surface, dst, closeio); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SaveBMPIO( + Ref surface, + IOStreamHandle dst, + [NativeTypeName("bool")] MaybeBool closeio + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SaveBMPIO(__dsl_surface, dst, (byte)closeio); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_scalbn")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Scalbn(double x, int n) => Underlying.Value!.Scalbn(x, n); + + [NativeFunction("SDL3", EntryPoint = "SDL_scalbnf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Scalbnf(float x, int n) => Underlying.Value!.Scalbnf(x, n); + + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Surface* ScaleSurface( + Surface* surface, + int width, + int height, + ScaleMode scaleMode + ) => Underlying.Value!.ScaleSurface(surface, width, height, scaleMode); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr ScaleSurface( + Ref surface, + int width, + int height, + ScaleMode scaleMode + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (Surface*)ScaleSurface(__dsl_surface, width, height, scaleMode); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ScreenKeyboardShown(WindowHandle window) => + Underlying.Value!.ScreenKeyboardShown(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ScreenKeyboardShownRaw(WindowHandle window) => + Underlying.Value!.ScreenKeyboardShownRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ScreenSaverEnabled() => + Underlying.Value!.ScreenSaverEnabled(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ScreenSaverEnabledRaw() => Underlying.Value!.ScreenSaverEnabledRaw(); + + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long SeekIO( + IOStreamHandle context, + [NativeTypeName("Sint64")] long offset, + IOWhence whence + ) => Underlying.Value!.SeekIO(context, offset, whence); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] void* data, + int size + ) => Underlying.Value!.SendGamepadEffect(gamepad, data, size); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] Ref data, + int size + ) + { + fixed (void* __dsl_data = data) + { + return (MaybeBool)(byte)SendGamepadEffect(gamepad, __dsl_data, size); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] void* data, + int size + ) => Underlying.Value!.SendJoystickEffect(joystick, data, size); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] Ref data, + int size + ) + { + fixed (void* __dsl_data = data) + { + return (MaybeBool)(byte)SendJoystickEffect(joystick, __dsl_data, size); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] float* data, + int num_values + ) => + Underlying.Value!.SendJoystickVirtualSensorData( + joystick, + type, + sensor_timestamp, + data, + num_values + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] Ref data, + int num_values + ) + { + fixed (float* __dsl_data = data) + { + return (MaybeBool) + (byte)SendJoystickVirtualSensorData( + joystick, + type, + sensor_timestamp, + __dsl_data, + num_values + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAppMetadata( + [NativeTypeName("const char *")] sbyte* appname, + [NativeTypeName("const char *")] sbyte* appversion, + [NativeTypeName("const char *")] sbyte* appidentifier + ) => Underlying.Value!.SetAppMetadata(appname, appversion, appidentifier); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAppMetadata( + [NativeTypeName("const char *")] Ref appname, + [NativeTypeName("const char *")] Ref appversion, + [NativeTypeName("const char *")] Ref appidentifier + ) + { + fixed (sbyte* __dsl_appidentifier = appidentifier) + fixed (sbyte* __dsl_appversion = appversion) + fixed (sbyte* __dsl_appname = appname) + { + return (MaybeBool) + (byte)SetAppMetadata(__dsl_appname, __dsl_appversion, __dsl_appidentifier); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAppMetadataProperty( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => Underlying.Value!.SetAppMetadataProperty(name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetAppMetadataProperty(__dsl_name, __dsl_value); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + void* userdata + ) => Underlying.Value!.SetAssertionHandler(handler, userdata); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + SetAssertionHandler(handler, __dsl_userdata); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int SetAtomicInt(AtomicInt* a, int v) => Underlying.Value!.SetAtomicInt(a, v); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int SetAtomicInt(Ref a, int v) + { + fixed (AtomicInt* __dsl_a = a) + { + return (int)SetAtomicInt(__dsl_a, v); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void* SetAtomicPointer(void** a, void* v) => + Underlying.Value!.SetAtomicPointer(a, v); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr SetAtomicPointer(Ref2D a, Ref v) + { + fixed (void* __dsl_v = v) + fixed (void** __dsl_a = a) + { + return (void*)SetAtomicPointer(__dsl_a, __dsl_v); + } + } + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => + Underlying.Value!.SetAtomicU32(a, v); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) + { + fixed (AtomicU32* __dsl_a = a) + { + return (uint)SetAtomicU32(__dsl_a, v); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioDeviceGain( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => Underlying.Value!.SetAudioDeviceGain(devid, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioDeviceGainRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => Underlying.Value!.SetAudioDeviceGainRaw(devid, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + void* userdata + ) => Underlying.Value!.SetAudioPostmixCallback(devid, callback, userdata); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte)SetAudioPostmixCallback(devid, callback, __dsl_userdata); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => Underlying.Value!.SetAudioStreamFormat(stream, src_spec, dst_spec); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) + { + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) + { + return (MaybeBool) + (byte)SetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamFrequencyRatio( + AudioStreamHandle stream, + float ratio + ) => Underlying.Value!.SetAudioStreamFrequencyRatio(stream, ratio); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => + Underlying.Value!.SetAudioStreamFrequencyRatioRaw(stream, ratio); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => + Underlying.Value!.SetAudioStreamGain(stream, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => + Underlying.Value!.SetAudioStreamGainRaw(stream, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => Underlying.Value!.SetAudioStreamGetCallback(stream, callback, userdata); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte)SetAudioStreamGetCallback(stream, callback, __dsl_userdata); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => Underlying.Value!.SetAudioStreamInputChannelMap(stream, chmap, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) + { + fixed (int* __dsl_chmap = chmap) + { + return (MaybeBool) + (byte)SetAudioStreamInputChannelMap(stream, __dsl_chmap, count); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => Underlying.Value!.SetAudioStreamOutputChannelMap(stream, chmap, count); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) + { + fixed (int* __dsl_chmap = chmap) + { + return (MaybeBool) + (byte)SetAudioStreamOutputChannelMap(stream, __dsl_chmap, count); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => Underlying.Value!.SetAudioStreamPutCallback(stream, callback, userdata); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte)SetAudioStreamPutCallback(stream, callback, __dsl_userdata); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte value + ) => Underlying.Value!.SetBooleanProperty(props, name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool value + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetBooleanProperty(props, __dsl_name, (byte)value); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + void* userdata, + [NativeTypeName("const char **")] sbyte** mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => + Underlying.Value!.SetClipboardData( + callback, + cleanup, + userdata, + mime_types, + num_mime_types + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + Ref userdata, + [NativeTypeName("const char **")] Ref2D mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) + { + fixed (sbyte** __dsl_mime_types = mime_types) + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte)SetClipboardData( + callback, + cleanup, + __dsl_userdata, + __dsl_mime_types, + num_mime_types + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => + Underlying.Value!.SetClipboardText(text); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetClipboardText( + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + return (MaybeBool)(byte)SetClipboardText(__dsl_text); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => + Underlying.Value!.SetCurrentThreadPriority(priority); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => + Underlying.Value!.SetCurrentThreadPriorityRaw(priority); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetCursor(CursorHandle cursor) => + Underlying.Value!.SetCursor(cursor); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetCursorRaw(CursorHandle cursor) => + Underlying.Value!.SetCursorRaw(cursor); + + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ) => Underlying.Value!.SetenvUnsafe(name, value, overwrite); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (int)SetenvUnsafe(__dsl_name, __dsl_value, overwrite); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ) => Underlying.Value!.SetEnvironmentVariable(env, name, value, overwrite); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)SetEnvironmentVariable(env, __dsl_name, __dsl_value, (byte)overwrite); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetErrorV( + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.SetErrorV(fmt, ap); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetErrorV( + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + { + return (MaybeBool)(byte)SetErrorV(__dsl_fmt, __dsl_ap); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] byte enabled + ) => Underlying.Value!.SetEventEnabled(type, enabled); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.SetEventEnabled(type, enabled); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => Underlying.Value!.SetEventFilter(filter, userdata); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + SetEventFilter(filter, __dsl_userdata); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float value + ) => Underlying.Value!.SetFloatProperty(props, name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float value + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetFloatProperty(props, __dsl_name, value); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => + Underlying.Value!.SetGamepadEventsEnabled(enabled); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGamepadEventsEnabled( + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.SetGamepadEventsEnabled(enabled); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetGamepadLED( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => Underlying.Value!.SetGamepadLED(gamepad, red, green, blue); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetGamepadLEDRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => Underlying.Value!.SetGamepadLEDRaw(gamepad, red, green, blue); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] sbyte* mapping + ) => Underlying.Value!.SetGamepadMapping(instance_id, mapping); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] Ref mapping + ) + { + fixed (sbyte* __dsl_mapping = mapping) + { + return (MaybeBool)(byte)SetGamepadMapping(instance_id, __dsl_mapping); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetGamepadPlayerIndex( + GamepadHandle gamepad, + int player_index + ) => Underlying.Value!.SetGamepadPlayerIndex(gamepad, player_index); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => + Underlying.Value!.SetGamepadPlayerIndexRaw(gamepad, player_index); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] byte enabled + ) => Underlying.Value!.SetGamepadSensorEnabled(gamepad, type, enabled); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.SetGamepadSensorEnabled(gamepad, type, enabled); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBlendConstants")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUBlendConstants( + GPURenderPassHandle render_pass, + FColor blend_constants + ) => Underlying.Value!.SetGPUBlendConstants(render_pass, blend_constants); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ) => Underlying.Value!.SetGPUBufferName(device, buffer, text); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + SetGPUBufferName(device, buffer, __dsl_text); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ) => Underlying.Value!.SetGPUScissor(render_pass, scissor); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ) + { + fixed (Rect* __dsl_scissor = scissor) + { + SetGPUScissor(render_pass, __dsl_scissor); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUStencilReference")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ) => Underlying.Value!.SetGPUStencilReference(render_pass, reference); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => + Underlying.Value!.SetGPUSwapchainParameters( + device, + window, + swapchain_composition, + present_mode + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => + Underlying.Value!.SetGPUSwapchainParametersRaw( + device, + window, + swapchain_composition, + present_mode + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ) => Underlying.Value!.SetGPUTextureName(device, texture, text); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + SetGPUTextureName(device, texture, __dsl_text); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ) => Underlying.Value!.SetGPUViewport(render_pass, viewport); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ) + { + fixed (GPUViewport* __dsl_viewport = viewport) + { + SetGPUViewport(render_pass, __dsl_viewport); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => + Underlying.Value!.SetHapticAutocenter(haptic, autocenter); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => + Underlying.Value!.SetHapticAutocenterRaw(haptic, autocenter); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetHapticGain(HapticHandle haptic, int gain) => + Underlying.Value!.SetHapticGain(haptic, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetHapticGainRaw(HapticHandle haptic, int gain) => + Underlying.Value!.SetHapticGainRaw(haptic, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetHint( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => Underlying.Value!.SetHint(name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetHint( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetHint(__dsl_name, __dsl_value); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetHintWithPriority( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + HintPriority priority + ) => Underlying.Value!.SetHintWithPriority(name, value, priority); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetHintWithPriority( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + HintPriority priority + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)SetHintWithPriority(__dsl_name, __dsl_value, priority); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetInitialized( + InitState* state, + [NativeTypeName("bool")] byte initialized + ) => Underlying.Value!.SetInitialized(state, initialized); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetInitialized( + Ref state, + [NativeTypeName("bool")] MaybeBool initialized + ) + { + fixed (InitState* __dsl_state = state) + { + SetInitialized(__dsl_state, (byte)initialized); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => + Underlying.Value!.SetJoystickEventsEnabled(enabled); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetJoystickEventsEnabled( + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.SetJoystickEventsEnabled(enabled); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickLED( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => Underlying.Value!.SetJoystickLED(joystick, red, green, blue); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickLEDRaw( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => Underlying.Value!.SetJoystickLEDRaw(joystick, red, green, blue); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickPlayerIndex( + JoystickHandle joystick, + int player_index + ) => Underlying.Value!.SetJoystickPlayerIndex(joystick, player_index); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => + Underlying.Value!.SetJoystickPlayerIndexRaw(joystick, player_index); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickVirtualAxis( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.SetJoystickVirtualAxis(joystick, axis, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickVirtualAxisRaw( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.SetJoystickVirtualAxisRaw(joystick, axis, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickVirtualBall( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => Underlying.Value!.SetJoystickVirtualBall(joystick, ball, xrel, yrel); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickVirtualBallRaw( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => Underlying.Value!.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] byte down + ) => Underlying.Value!.SetJoystickVirtualButton(joystick, button, down); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] MaybeBool down + ) => Underlying.Value!.SetJoystickVirtualButton(joystick, button, down); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickVirtualHat( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => Underlying.Value!.SetJoystickVirtualHat(joystick, hat, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickVirtualHatRaw( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => Underlying.Value!.SetJoystickVirtualHatRaw(joystick, hat, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] byte down, + float x, + float y, + float pressure + ) => + Underlying.Value!.SetJoystickVirtualTouchpad( + joystick, + touchpad, + finger, + down, + x, + y, + pressure + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] MaybeBool down, + float x, + float y, + float pressure + ) => + Underlying.Value!.SetJoystickVirtualTouchpad( + joystick, + touchpad, + finger, + down, + x, + y, + pressure + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, + void* userdata + ) => Underlying.Value!.SetLogOutputFunction(callback, userdata); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + SetLogOutputFunction(callback, __dsl_userdata); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetLogPriorities(LogPriority priority) => + Underlying.Value!.SetLogPriorities(priority); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetLogPriority(int category, LogPriority priority) => + Underlying.Value!.SetLogPriority(category, priority); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] sbyte* prefix + ) => Underlying.Value!.SetLogPriorityPrefix(priority, prefix); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] Ref prefix + ) + { + fixed (sbyte* __dsl_prefix = prefix) + { + return (MaybeBool)(byte)SetLogPriorityPrefix(priority, __dsl_prefix); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_SetMainReady")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetMainReady() => Underlying.Value!.SetMainReady(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => + Underlying.Value!.SetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => + Underlying.Value!.SetMemoryFunctionsRaw( + malloc_func, + calloc_func, + realloc_func, + free_func + ); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => + Underlying.Value!.SetModState(modstate); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long value + ) => Underlying.Value!.SetNumberProperty(props, name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long value + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetNumberProperty(props, __dsl_name, value); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetPaletteColors( + Palette* palette, + [NativeTypeName("const SDL_Color *")] Color* colors, + int firstcolor, + int ncolors + ) => Underlying.Value!.SetPaletteColors(palette, colors, firstcolor, ncolors); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetPaletteColors( + Ref palette, + [NativeTypeName("const SDL_Color *")] Ref colors, + int firstcolor, + int ncolors + ) + { + fixed (Color* __dsl_colors = colors) + fixed (Palette* __dsl_palette = palette) + { + return (MaybeBool) + (byte)SetPaletteColors(__dsl_palette, __dsl_colors, firstcolor, ncolors); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value + ) => Underlying.Value!.SetPointerProperty(props, name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value + ) + { + fixed (void* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetPointerProperty(props, __dsl_name, __dsl_value); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetPointerPropertyWithCleanup( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + void* userdata + ) => Underlying.Value!.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetPointerPropertyWithCleanup( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)SetPointerPropertyWithCleanup( + props, + __dsl_name, + __dsl_value, + cleanup, + __dsl_userdata + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => + Underlying.Value!.SetPrimarySelectionText(text); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetPrimarySelectionText( + [NativeTypeName("const char *")] Ref text + ) + { + fixed (sbyte* __dsl_text = text) + { + return (MaybeBool)(byte)SetPrimarySelectionText(__dsl_text); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => Underlying.Value!.SetRenderClipRect(renderer, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)SetRenderClipRect(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => + Underlying.Value!.SetRenderColorScale(renderer, scale); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => + Underlying.Value!.SetRenderColorScaleRaw(renderer, scale); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => Underlying.Value!.SetRenderDrawBlendMode(renderer, blendMode); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderDrawBlendModeRaw( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => Underlying.Value!.SetRenderDrawBlendModeRaw(renderer, blendMode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => Underlying.Value!.SetRenderDrawColor(renderer, r, g, b, a); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderDrawColorFloat( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => Underlying.Value!.SetRenderDrawColorFloat(renderer, r, g, b, a); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderDrawColorFloatRaw( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => Underlying.Value!.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderDrawColorRaw( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => Underlying.Value!.SetRenderDrawColorRaw(renderer, r, g, b, a); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderLogicalPresentation( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => Underlying.Value!.SetRenderLogicalPresentation(renderer, w, h, mode); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderLogicalPresentationRaw( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => Underlying.Value!.SetRenderLogicalPresentationRaw(renderer, w, h, mode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderScale( + RendererHandle renderer, + float scaleX, + float scaleY + ) => Underlying.Value!.SetRenderScale(renderer, scaleX, scaleY); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => + Underlying.Value!.SetRenderScaleRaw(renderer, scaleX, scaleY); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderTarget(RendererHandle renderer, Texture* texture) => + Underlying.Value!.SetRenderTarget(renderer, texture); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetRenderTarget(renderer, __dsl_texture); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => Underlying.Value!.SetRenderViewport(renderer, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)SetRenderViewport(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => + Underlying.Value!.SetRenderVSync(renderer, vsync); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => + Underlying.Value!.SetRenderVSyncRaw(renderer, vsync); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.SetScancodeName(scancode, name); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetScancodeName(scancode, __dsl_name); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => Underlying.Value!.SetStringProperty(props, name, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)SetStringProperty(props, __dsl_name, __dsl_value); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceAlphaMod( + Surface* surface, + [NativeTypeName("Uint8")] byte alpha + ) => Underlying.Value!.SetSurfaceAlphaMod(surface, alpha); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8")] byte alpha + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceAlphaMod(__dsl_surface, alpha); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => Underlying.Value!.SetSurfaceBlendMode(surface, blendMode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceBlendMode(__dsl_surface, blendMode); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceClipRect( + Surface* surface, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => Underlying.Value!.SetSurfaceClipRect(surface, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceClipRect( + Ref surface, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceClipRect(__dsl_surface, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceColorKey( + Surface* surface, + [NativeTypeName("bool")] byte enabled, + [NativeTypeName("Uint32")] uint key + ) => Underlying.Value!.SetSurfaceColorKey(surface, enabled, key); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceColorKey( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled, + [NativeTypeName("Uint32")] uint key + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceColorKey(__dsl_surface, (byte)enabled, key); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => Underlying.Value!.SetSurfaceColorMod(surface, r, g, b); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceColorMod(__dsl_surface, r, g, b); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => + Underlying.Value!.SetSurfaceColorspace(surface, colorspace); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceColorspace( + Ref surface, + Colorspace colorspace + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceColorspace(__dsl_surface, colorspace); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfacePalette(Surface* surface, Palette* palette) => + Underlying.Value!.SetSurfacePalette(surface, palette); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfacePalette(Ref surface, Ref palette) + { + fixed (Palette* __dsl_palette = palette) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfacePalette(__dsl_surface, __dsl_palette); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => + Underlying.Value!.SetSurfaceRLE(surface, enabled); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetSurfaceRLE( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SetSurfaceRLE(__dsl_surface, (byte)enabled); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int cursor + ) => Underlying.Value!.SetTextInputArea(window, rect, cursor); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect, + int cursor + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)SetTextInputArea(window, __dsl_rect, cursor); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureAlphaMod( + Texture* texture, + [NativeTypeName("Uint8")] byte alpha + ) => Underlying.Value!.SetTextureAlphaMod(texture, alpha); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8")] byte alpha + ) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureAlphaMod(__dsl_texture, alpha); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureAlphaModFloat(Texture* texture, float alpha) => + Underlying.Value!.SetTextureAlphaModFloat(texture, alpha); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureAlphaModFloat(__dsl_texture, alpha); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => Underlying.Value!.SetTextureBlendMode(texture, blendMode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureBlendMode(__dsl_texture, blendMode); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => Underlying.Value!.SetTextureColorMod(texture, r, g, b); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureColorMod(__dsl_texture, r, g, b); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => + Underlying.Value!.SetTextureColorModFloat(texture, r, g, b); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureColorModFloat( + Ref texture, + float r, + float g, + float b + ) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureColorModFloat(__dsl_texture, r, g, b); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => + Underlying.Value!.SetTextureScaleMode(texture, scaleMode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) + { + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool)(byte)SetTextureScaleMode(__dsl_texture, scaleMode); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetTLS( + [NativeTypeName("SDL_TLSID *")] AtomicInt* id, + [NativeTypeName("const void *")] void* value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) => Underlying.Value!.SetTLS(id, value, destructor); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetTLS( + [NativeTypeName("SDL_TLSID *")] Ref id, + [NativeTypeName("const void *")] Ref value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) + { + fixed (void* __dsl_value = value) + fixed (AtomicInt* __dsl_id = id) + { + return (MaybeBool)(byte)SetTLS(__dsl_id, __dsl_value, destructor); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] byte on_top + ) => Underlying.Value!.SetWindowAlwaysOnTop(window, on_top); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool on_top + ) => Underlying.Value!.SetWindowAlwaysOnTop(window, on_top); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowAspectRatio( + WindowHandle window, + float min_aspect, + float max_aspect + ) => Underlying.Value!.SetWindowAspectRatio(window, min_aspect, max_aspect); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowAspectRatioRaw( + WindowHandle window, + float min_aspect, + float max_aspect + ) => Underlying.Value!.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] byte bordered + ) => Underlying.Value!.SetWindowBordered(window, bordered); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool bordered + ) => Underlying.Value!.SetWindowBordered(window, bordered); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] byte focusable + ) => Underlying.Value!.SetWindowFocusable(window, focusable); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool focusable + ) => Underlying.Value!.SetWindowFocusable(window, focusable); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] byte fullscreen + ) => Underlying.Value!.SetWindowFullscreen(window, fullscreen); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool fullscreen + ) => Underlying.Value!.SetWindowFullscreen(window, fullscreen); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode + ) => Underlying.Value!.SetWindowFullscreenMode(window, mode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] Ref mode + ) + { + fixed (DisplayMode* __dsl_mode = mode) + { + return (MaybeBool)(byte)SetWindowFullscreenMode(window, __dsl_mode); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + void* callback_data + ) => Underlying.Value!.SetWindowHitTest(window, callback, callback_data); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + Ref callback_data + ) + { + fixed (void* __dsl_callback_data = callback_data) + { + return (MaybeBool) + (byte)SetWindowHitTest(window, callback, __dsl_callback_data); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowIcon(WindowHandle window, Surface* icon) => + Underlying.Value!.SetWindowIcon(window, icon); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowIcon(WindowHandle window, Ref icon) + { + fixed (Surface* __dsl_icon = icon) + { + return (MaybeBool)(byte)SetWindowIcon(window, __dsl_icon); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => Underlying.Value!.SetWindowKeyboardGrab(window, grabbed); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => Underlying.Value!.SetWindowKeyboardGrab(window, grabbed); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowMaximumSize( + WindowHandle window, + int max_w, + int max_h + ) => Underlying.Value!.SetWindowMaximumSize(window, max_w, max_h); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => + Underlying.Value!.SetWindowMaximumSizeRaw(window, max_w, max_h); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowMinimumSize( + WindowHandle window, + int min_w, + int min_h + ) => Underlying.Value!.SetWindowMinimumSize(window, min_w, min_h); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => + Underlying.Value!.SetWindowMinimumSizeRaw(window, min_w, min_h); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowModal( + WindowHandle window, + [NativeTypeName("bool")] byte modal + ) => Underlying.Value!.SetWindowModal(window, modal); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowModal( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool modal + ) => Underlying.Value!.SetWindowModal(window, modal); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => Underlying.Value!.SetWindowMouseGrab(window, grabbed); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => Underlying.Value!.SetWindowMouseGrab(window, grabbed); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => Underlying.Value!.SetWindowMouseRect(window, rect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)SetWindowMouseRect(window, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => + Underlying.Value!.SetWindowOpacity(window, opacity); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowOpacityRaw(WindowHandle window, float opacity) => + Underlying.Value!.SetWindowOpacityRaw(window, opacity); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => + Underlying.Value!.SetWindowParent(window, parent); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => + Underlying.Value!.SetWindowParentRaw(window, parent); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => + Underlying.Value!.SetWindowPosition(window, x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowPositionRaw(WindowHandle window, int x, int y) => + Underlying.Value!.SetWindowPositionRaw(window, x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] byte enabled + ) => Underlying.Value!.SetWindowRelativeMouseMode(window, enabled); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool enabled + ) => Underlying.Value!.SetWindowRelativeMouseMode(window, enabled); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] byte resizable + ) => Underlying.Value!.SetWindowResizable(window, resizable); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool resizable + ) => Underlying.Value!.SetWindowResizable(window, resizable); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowShape(WindowHandle window, Surface* shape) => + Underlying.Value!.SetWindowShape(window, shape); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowShape(WindowHandle window, Ref shape) + { + fixed (Surface* __dsl_shape = shape) + { + return (MaybeBool)(byte)SetWindowShape(window, __dsl_shape); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowSize(WindowHandle window, int w, int h) => + Underlying.Value!.SetWindowSize(window, w, h); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowSizeRaw(WindowHandle window, int w, int h) => + Underlying.Value!.SetWindowSizeRaw(window, w, h); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => + Underlying.Value!.SetWindowSurfaceVSync(window, vsync); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => + Underlying.Value!.SetWindowSurfaceVSyncRaw(window, vsync); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SetWindowTitle( + WindowHandle window, + [NativeTypeName("const char *")] sbyte* title + ) => Underlying.Value!.SetWindowTitle(window, title); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SetWindowTitle( + WindowHandle window, + [NativeTypeName("const char *")] Ref title + ) + { + fixed (sbyte* __dsl_title = title) + { + return (MaybeBool)(byte)SetWindowTitle(window, __dsl_title); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShouldInit(InitState* state) => Underlying.Value!.ShouldInit(state); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShouldInit(Ref state) + { + fixed (InitState* __dsl_state = state) + { + return (MaybeBool)(byte)ShouldInit(__dsl_state); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShouldQuit(InitState* state) => Underlying.Value!.ShouldQuit(state); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShouldQuit(Ref state) + { + fixed (InitState* __dsl_state = state) + { + return (MaybeBool)(byte)ShouldQuit(__dsl_state); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShowCursor() => Underlying.Value!.ShowCursor(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShowCursorRaw() => Underlying.Value!.ShowCursorRaw(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, + int* buttonid + ) => Underlying.Value!.ShowMessageBox(messageboxdata, buttonid); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, + Ref buttonid + ) + { + fixed (int* __dsl_buttonid = buttonid) + fixed (MessageBoxData* __dsl_messageboxdata = messageboxdata) + { + return (MaybeBool)(byte)ShowMessageBox(__dsl_messageboxdata, __dsl_buttonid); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => + Underlying.Value!.ShowOpenFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location, + allow_many + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) + { + fixed (sbyte* __dsl_default_location = default_location) + fixed (DialogFileFilter* __dsl_filters = filters) + fixed (void* __dsl_userdata = userdata) + { + ShowOpenFileDialog( + callback, + __dsl_userdata, + window, + __dsl_filters, + nfilters, + __dsl_default_location, + (byte)allow_many + ); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => + Underlying.Value!.ShowOpenFolderDialog( + callback, + userdata, + window, + default_location, + allow_many + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) + { + fixed (sbyte* __dsl_default_location = default_location) + fixed (void* __dsl_userdata = userdata) + { + ShowOpenFolderDialog( + callback, + __dsl_userdata, + window, + __dsl_default_location, + (byte)allow_many + ); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location + ) => + Underlying.Value!.ShowSaveFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location + ); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location + ) + { + fixed (sbyte* __dsl_default_location = default_location) + fixed (DialogFileFilter* __dsl_filters = filters) + fixed (void* __dsl_userdata = userdata) + { + ShowSaveFileDialog( + callback, + __dsl_userdata, + window, + __dsl_filters, + nfilters, + __dsl_default_location + ); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] sbyte* title, + [NativeTypeName("const char *")] sbyte* message, + WindowHandle window + ) => Underlying.Value!.ShowSimpleMessageBox(flags, title, message, window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] Ref title, + [NativeTypeName("const char *")] Ref message, + WindowHandle window + ) + { + fixed (sbyte* __dsl_message = message) + fixed (sbyte* __dsl_title = title) + { + return (MaybeBool) + (byte)ShowSimpleMessageBox(flags, __dsl_title, __dsl_message, window); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShowWindow(WindowHandle window) => + Underlying.Value!.ShowWindow(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShowWindowRaw(WindowHandle window) => + Underlying.Value!.ShowWindowRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => + Underlying.Value!.ShowWindowSystemMenu(window, x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => + Underlying.Value!.ShowWindowSystemMenuRaw(window, x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SignalCondition(ConditionHandle cond) => + Underlying.Value!.SignalCondition(cond); + + [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void SignalSemaphore(SemaphoreHandle sem) => + Underlying.Value!.SignalSemaphore(sem); + + [NativeFunction("SDL3", EntryPoint = "SDL_sin")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Sin(double x) => Underlying.Value!.Sin(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sinf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Sinf(float x) => Underlying.Value!.Sinf(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrt")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Sqrt(double x) => Underlying.Value!.Sqrt(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_sqrtf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Sqrtf(float x) => Underlying.Value!.Sqrtf(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_srand")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void Srand([NativeTypeName("Uint64")] ulong seed) => + Underlying.Value!.Srand(seed); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StartTextInput(WindowHandle window) => + Underlying.Value!.StartTextInput(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StartTextInputRaw(WindowHandle window) => + Underlying.Value!.StartTextInputRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StartTextInputWithProperties( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.StartTextInputWithProperties(window, props); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StartTextInputWithPropertiesRaw( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => Underlying.Value!.StartTextInputWithPropertiesRaw(window, props); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ) => Underlying.Value!.StepBackUTF8(start, pstr); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ) + { + fixed (sbyte** __dsl_pstr = pstr) + fixed (sbyte* __dsl_start = start) + { + return (uint)StepBackUTF8(__dsl_start, __dsl_pstr); + } + } + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ) => Underlying.Value!.StepUTF8(pstr, pslen); + + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ) + { + fixed (nuint* __dsl_pslen = pslen) + fixed (sbyte** __dsl_pstr = pstr) + { + return (uint)StepUTF8(__dsl_pstr, __dsl_pslen); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => + Underlying.Value!.StopHapticEffect(haptic, effect); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StopHapticEffectRaw(HapticHandle haptic, int effect) => + Underlying.Value!.StopHapticEffectRaw(haptic, effect); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StopHapticEffects(HapticHandle haptic) => + Underlying.Value!.StopHapticEffects(haptic); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StopHapticEffectsRaw(HapticHandle haptic) => + Underlying.Value!.StopHapticEffectsRaw(haptic); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StopHapticRumble(HapticHandle haptic) => + Underlying.Value!.StopHapticRumble(haptic); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StopHapticRumbleRaw(HapticHandle haptic) => + Underlying.Value!.StopHapticRumbleRaw(haptic); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StopTextInput(WindowHandle window) => + Underlying.Value!.StopTextInput(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StopTextInputRaw(WindowHandle window) => + Underlying.Value!.StopTextInputRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool StorageReady(StorageHandle storage) => + Underlying.Value!.StorageReady(storage); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte StorageReadyRaw(StorageHandle storage) => + Underlying.Value!.StorageReadyRaw(storage); + + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => Underlying.Value!.Strcasecmp(str1, str2); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)Strcasecmp(__dsl_str1, __dsl_str2); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => Underlying.Value!.Strcasestr(haystack, needle); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) + { + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) + { + return (sbyte*)Strcasestr(__dsl_haystack, __dsl_needle); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c) => + Underlying.Value!.Strchr(str, c); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strchr([NativeTypeName("const char *")] Ref str, int c) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strchr(__dsl_str, c); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => Underlying.Value!.Strcmp(str1, str2); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)Strcmp(__dsl_str1, __dsl_str2); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strdup([NativeTypeName("const char *")] sbyte* str) => + Underlying.Value!.Strdup(str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strdup([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strdup(__dsl_str); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => + Underlying.Value!.StringToGuid(pchGUID); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) + { + fixed (sbyte* __dsl_pchGUID = pchGUID) + { + return (Guid)StringToGuid(__dsl_pchGUID); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strlcat(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) + { + return (nuint)Strlcat(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strlcpy(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) + { + return (nuint)Strlcpy(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlen([NativeTypeName("const char *")] sbyte* str) => + Underlying.Value!.Strlen(str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strlen([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Strlen(__dsl_str); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strlwr([NativeTypeName("char *")] sbyte* str) => + Underlying.Value!.Strlwr(str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strlwr([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strlwr(__dsl_str); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strncasecmp(str1, str2, maxlen); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)Strncasecmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strncmp(str1, str2, maxlen); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)Strncmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strndup(str, maxlen); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strndup(__dsl_str, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strnlen(str, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Strnlen(__dsl_str, maxlen); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Strnstr(haystack, needle, maxlen); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) + { + return (sbyte*)Strnstr(__dsl_haystack, __dsl_needle, maxlen); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ) => Underlying.Value!.Strpbrk(str, breakset); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ) + { + fixed (sbyte* __dsl_breakset = breakset) + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strpbrk(__dsl_str, __dsl_breakset); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c) => + Underlying.Value!.Strrchr(str, c); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strrchr(__dsl_str, c); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strrev([NativeTypeName("char *")] sbyte* str) => + Underlying.Value!.Strrev(str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strrev([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strrev(__dsl_str); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => Underlying.Value!.Strstr(haystack, needle); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) + { + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) + { + return (sbyte*)Strstr(__dsl_haystack, __dsl_needle); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ) => Underlying.Value!.Strtod(str, endp); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (double)Strtod(__dsl_str, __dsl_endp); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ) => Underlying.Value!.StrtokR(s1, s2, saveptr); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ) + { + fixed (sbyte** __dsl_saveptr = saveptr) + fixed (sbyte* __dsl_s2 = s2) + fixed (sbyte* __dsl_s1 = s1) + { + return (sbyte*)StrtokR(__dsl_s1, __dsl_s2, __dsl_saveptr); + } + } + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => Underlying.Value!.Strtol(str, endp, @base); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (nint)Strtol(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => Underlying.Value!.Strtoll(str, endp, @base); + + [return: NativeTypeName("long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (long)Strtoll(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("unsigned long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => Underlying.Value!.Strtoul(str, endp, @base); + + [return: NativeTypeName("unsigned long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (nuint)Strtoul(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("unsigned long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => Underlying.Value!.Strtoull(str, endp, @base); + + [return: NativeTypeName("unsigned long long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (ulong)Strtoull(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Strupr([NativeTypeName("char *")] sbyte* str) => + Underlying.Value!.Strupr(str); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Strupr([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Strupr(__dsl_str); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SubmitGPUCommandBuffer( + GPUCommandBufferHandle command_buffer + ) => Underlying.Value!.SubmitGPUCommandBuffer(command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ) => Underlying.Value!.SubmitGPUCommandBufferAndAcquireFence(command_buffer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + Underlying.Value!.SubmitGPUCommandBufferRaw(command_buffer); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SurfaceHasAlternateImages(Surface* surface) => + Underlying.Value!.SurfaceHasAlternateImages(surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasAlternateImages")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SurfaceHasAlternateImages(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SurfaceHasAlternateImages(__dsl_surface); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SurfaceHasColorKey(Surface* surface) => + Underlying.Value!.SurfaceHasColorKey(surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasColorKey")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SurfaceHasColorKey(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SurfaceHasColorKey(__dsl_surface); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SurfaceHasRLE(Surface* surface) => + Underlying.Value!.SurfaceHasRLE(surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SurfaceHasRLE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SurfaceHasRLE(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)SurfaceHasRLE(__dsl_surface); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool SyncWindow(WindowHandle window) => + Underlying.Value!.SyncWindow(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SyncWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte SyncWindowRaw(WindowHandle window) => + Underlying.Value!.SyncWindowRaw(window); + + [NativeFunction("SDL3", EntryPoint = "SDL_tan")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Tan(double x) => Underlying.Value!.Tan(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tanf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Tanf(float x) => Underlying.Value!.Tanf(x); + + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_TellIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long TellIO(IOStreamHandle context) => Underlying.Value!.TellIO(context); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TextInputActive(WindowHandle window) => + Underlying.Value!.TextInputActive(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TextInputActive")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TextInputActiveRaw(WindowHandle window) => + Underlying.Value!.TextInputActiveRaw(window); + + [return: NativeTypeName("SDL_Time")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeFromWindows")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static long TimeFromWindows( + [NativeTypeName("Uint32")] uint dwLowDateTime, + [NativeTypeName("Uint32")] uint dwHighDateTime + ) => Underlying.Value!.TimeFromWindows(dwLowDateTime, dwHighDateTime); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + DateTime* dt, + [NativeTypeName("bool")] byte localTime + ) => Underlying.Value!.TimeToDateTime(ticks, dt, localTime); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToDateTime")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TimeToDateTime( + [NativeTypeName("SDL_Time")] long ticks, + Ref dt, + [NativeTypeName("bool")] MaybeBool localTime + ) + { + fixed (DateTime* __dsl_dt = dt) + { + return (MaybeBool)(byte)TimeToDateTime(ticks, __dsl_dt, (byte)localTime); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] uint* dwLowDateTime, + [NativeTypeName("Uint32 *")] uint* dwHighDateTime + ) => Underlying.Value!.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TimeToWindows")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void TimeToWindows( + [NativeTypeName("SDL_Time")] long ticks, + [NativeTypeName("Uint32 *")] Ref dwLowDateTime, + [NativeTypeName("Uint32 *")] Ref dwHighDateTime + ) + { + fixed (uint* __dsl_dwHighDateTime = dwHighDateTime) + fixed (uint* __dsl_dwLowDateTime = dwLowDateTime) + { + TimeToWindows(ticks, __dsl_dwLowDateTime, __dsl_dwHighDateTime); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_tolower")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Tolower(int x) => Underlying.Value!.Tolower(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_toupper")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Toupper(int x) => Underlying.Value!.Toupper(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_trunc")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static double Trunc(double x) => Underlying.Value!.Trunc(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_truncf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static float Truncf(float x) => Underlying.Value!.Truncf(x); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TryLockMutex(MutexHandle mutex) => + Underlying.Value!.TryLockMutex(mutex); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockMutex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TryLockMutexRaw(MutexHandle mutex) => + Underlying.Value!.TryLockMutexRaw(mutex); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => + Underlying.Value!.TryLockRWLockForReading(rwlock); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForReading")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TryLockRWLockForReadingRaw(RWLockHandle rwlock) => + Underlying.Value!.TryLockRWLockForReadingRaw(rwlock); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => + Underlying.Value!.TryLockRWLockForWriting(rwlock); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockRWLockForWriting")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TryLockRWLockForWritingRaw(RWLockHandle rwlock) => + Underlying.Value!.TryLockRWLockForWritingRaw(rwlock); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + Underlying.Value!.TryLockSpinlock(@lock); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryLockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TryLockSpinlock( + [NativeTypeName("SDL_SpinLock *")] Ref @lock + ) + { + fixed (int* __dsl_lock = @lock) + { + return (MaybeBool)(byte)TryLockSpinlock(__dsl_lock); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => + Underlying.Value!.TryWaitSemaphore(sem); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => + Underlying.Value!.TryWaitSemaphoreRaw(sem); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ) => Underlying.Value!.UCS4ToUTF8(codepoint, dst); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ) + { + fixed (sbyte* __dsl_dst = dst) + { + return (sbyte*)UCS4ToUTF8(codepoint, __dsl_dst); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => Underlying.Value!.Uitoa(value, str, radix); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Uitoa(value, __dsl_str, radix); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => Underlying.Value!.Ulltoa(value, str, radix); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ulltoa(value, __dsl_str, radix); + } + } + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => Underlying.Value!.Ultoa(value, str, radix); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)Ultoa(value, __dsl_str, radix); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnbindAudioStream(AudioStreamHandle stream) => + Underlying.Value!.UnbindAudioStream(stream); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnbindAudioStreams(AudioStreamHandle* streams, int num_streams) => + Underlying.Value!.UnbindAudioStreams(streams, num_streams); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnbindAudioStreams")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnbindAudioStreams(Ref streams, int num_streams) + { + fixed (AudioStreamHandle* __dsl_streams = streams) + { + UnbindAudioStreams(__dsl_streams, num_streams); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UnloadObject")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnloadObject(SharedObjectHandle handle) => + Underlying.Value!.UnloadObject(handle); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UnlockAudioStream(AudioStreamHandle stream) => + Underlying.Value!.UnlockAudioStream(stream); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockAudioStream")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UnlockAudioStreamRaw(AudioStreamHandle stream) => + Underlying.Value!.UnlockAudioStreamRaw(stream); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockJoysticks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockJoysticks() => Underlying.Value!.UnlockJoysticks(); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockMutex")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockMutex(MutexHandle mutex) => Underlying.Value!.UnlockMutex(mutex); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockProperties")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + Underlying.Value!.UnlockProperties(props); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockRWLock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockRWLock(RWLockHandle rwlock) => + Underlying.Value!.UnlockRWLock(rwlock); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + Underlying.Value!.UnlockSpinlock(@lock); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSpinlock")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + { + fixed (int* __dsl_lock = @lock) + { + UnlockSpinlock(__dsl_lock); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockSurface(Surface* surface) => + Underlying.Value!.UnlockSurface(surface); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockSurface(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + UnlockSurface(__dsl_surface); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockTexture(Texture* texture) => + Underlying.Value!.UnlockTexture(texture); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnlockTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnlockTexture(Ref texture) + { + fixed (Texture* __dsl_texture = texture) + { + UnlockTexture(__dsl_texture); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UnmapGPUTransferBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => Underlying.Value!.UnmapGPUTransferBuffer(device, transfer_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + Underlying.Value!.UnsetenvUnsafe(name); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (int)UnsetenvUnsafe(__dsl_name); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => Underlying.Value!.UnsetEnvironmentVariable(env, name); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)UnsetEnvironmentVariable(env, __dsl_name); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateGamepads")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UpdateGamepads() => Underlying.Value!.UpdateGamepads(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* data + ) => Underlying.Value!.UpdateHapticEffect(haptic, effect, data); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateHapticEffect")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("const SDL_HapticEffect *")] Ref data + ) + { + fixed (HapticEffect* __dsl_data = data) + { + return (MaybeBool)(byte)UpdateHapticEffect(haptic, effect, __dsl_data); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateJoysticks")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UpdateJoysticks() => Underlying.Value!.UpdateJoysticks(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateNVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* UVplane, + int UVpitch + ) => Underlying.Value!.UpdateNVTexture(texture, rect, Yplane, Ypitch, UVplane, UVpitch); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateNVTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateNVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref UVplane, + int UVpitch + ) + { + fixed (byte* __dsl_UVplane = UVplane) + fixed (byte* __dsl_Yplane = Yplane) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateNVTexture( + __dsl_texture, + __dsl_rect, + __dsl_Yplane, + Ypitch, + __dsl_UVplane, + UVpitch + ); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateSensors")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UpdateSensors() => Underlying.Value!.UpdateSensors(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const void *")] void* pixels, + int pitch + ) => Underlying.Value!.UpdateTexture(texture, rect, pixels, pitch); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const void *")] Ref pixels, + int pitch + ) + { + fixed (void* __dsl_pixels = pixels) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateTexture(__dsl_texture, __dsl_rect, __dsl_pixels, pitch); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateWindowSurface(WindowHandle window) => + Underlying.Value!.UpdateWindowSurface(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateWindowSurfaceRaw(WindowHandle window) => + Underlying.Value!.UpdateWindowSurfaceRaw(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int numrects + ) => Underlying.Value!.UpdateWindowSurfaceRects(window, rects, numrects); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateWindowSurfaceRects")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateWindowSurfaceRects( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rects, + int numrects + ) + { + fixed (Rect* __dsl_rects = rects) + { + return (MaybeBool) + (byte)UpdateWindowSurfaceRects(window, __dsl_rects, numrects); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte UpdateYUVTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("const Uint8 *")] byte* Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] byte* Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] byte* Vplane, + int Vpitch + ) => + Underlying.Value!.UpdateYUVTexture( + texture, + rect, + Yplane, + Ypitch, + Uplane, + Upitch, + Vplane, + Vpitch + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UpdateYUVTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool UpdateYUVTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("const Uint8 *")] Ref Yplane, + int Ypitch, + [NativeTypeName("const Uint8 *")] Ref Uplane, + int Upitch, + [NativeTypeName("const Uint8 *")] Ref Vplane, + int Vpitch + ) + { + fixed (byte* __dsl_Vplane = Vplane) + fixed (byte* __dsl_Uplane = Uplane) + fixed (byte* __dsl_Yplane = Yplane) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)UpdateYUVTexture( + __dsl_texture, + __dsl_rect, + __dsl_Yplane, + Ypitch, + __dsl_Uplane, + Upitch, + __dsl_Vplane, + Vpitch + ); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => Underlying.Value!.UploadToGPUBuffer(copy_pass, source, destination, cycle); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUBufferRegion* __dsl_destination = destination) + fixed (GPUTransferBufferLocation* __dsl_source = source) + { + UploadToGPUBuffer(copy_pass, __dsl_source, __dsl_destination, (byte)cycle); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => Underlying.Value!.UploadToGPUTexture(copy_pass, source, destination, cycle); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUTextureRegion* __dsl_destination = destination) + fixed (GPUTextureTransferInfo* __dsl_source = source) + { + UploadToGPUTexture(copy_pass, __dsl_source, __dsl_destination, (byte)cycle); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => Underlying.Value!.Utf8Strlcpy(dst, src, dst_bytes); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ) + { + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) + { + return (nuint)Utf8Strlcpy(__dsl_dst, __dsl_src, dst_bytes); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str) => + Underlying.Value!.Utf8Strlen(str); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strlen([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Utf8Strlen(__dsl_str); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ) => Underlying.Value!.Utf8Strnlen(str, bytes); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)Utf8Strnlen(__dsl_str, bytes); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.Vasprintf(strp, fmt, ap); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte** __dsl_strp = strp) + { + return (int)Vasprintf(__dsl_strp, __dsl_fmt, __dsl_ap); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.Vsnprintf(text, maxlen, fmt, ap); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)Vsnprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.Vsscanf(text, fmt, ap); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)Vsscanf(__dsl_text, __dsl_fmt, __dsl_ap); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => Underlying.Value!.Vswprintf(text, maxlen, fmt, ap); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (uint* __dsl_fmt = fmt) + fixed (uint* __dsl_text = text) + { + return (int)Vswprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ) => Underlying.Value!.VulkanCreateSurface(window, instance, allocator, surface); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ) + { + fixed (ulong* __dsl_surface = surface) + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte)VulkanCreateSurface( + window, + __dsl_instance, + __dsl_allocator, + __dsl_surface + ); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ) => Underlying.Value!.VulkanDestroySurface(instance, surface, allocator); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ) + { + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + VulkanDestroySurface(__dsl_instance, surface, __dsl_allocator); + } + } + + [return: NativeTypeName("const char *const *")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static sbyte** VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] uint* count + ) => Underlying.Value!.VulkanGetInstanceExtensions(count); + + [return: NativeTypeName("const char *const *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr2D VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] Ref count + ) + { + fixed (uint* __dsl_count = count) + { + return (sbyte**)VulkanGetInstanceExtensions(__dsl_count); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => + Underlying.Value!.VulkanGetPresentationSupport( + instance, + physicalDevice, + queueFamilyIndex + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) + { + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte)VulkanGetPresentationSupport( + __dsl_instance, + physicalDevice, + queueFamilyIndex + ); + } + } + + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static FunctionPointer VulkanGetVkGetInstanceProcAddr() => + Underlying.Value!.VulkanGetVkGetInstanceProcAddr(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + Underlying.Value!.VulkanLoadLibrary(path); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool VulkanLoadLibrary( + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)VulkanLoadLibrary(__dsl_path); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_UnloadLibrary")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void VulkanUnloadLibrary() => Underlying.Value!.VulkanUnloadLibrary(); + + [NativeFunction("SDL3", EntryPoint = "SDL_WaitCondition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void WaitCondition(ConditionHandle cond, MutexHandle mutex) => + Underlying.Value!.WaitCondition(cond, mutex); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitConditionTimeout( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ) => Underlying.Value!.WaitConditionTimeout(cond, mutex, timeoutMS); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitConditionTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitConditionTimeoutRaw( + ConditionHandle cond, + MutexHandle mutex, + [NativeTypeName("Sint32")] int timeoutMS + ) => Underlying.Value!.WaitConditionTimeoutRaw(cond, mutex, timeoutMS); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitEvent(Event* @event) => Underlying.Value!.WaitEvent(@event); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEvent")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitEvent(Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)WaitEvent(__dsl_event); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitEventTimeout( + Event* @event, + [NativeTypeName("Sint32")] int timeoutMS + ) => Underlying.Value!.WaitEventTimeout(@event, timeoutMS); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitEventTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitEventTimeout( + Ref @event, + [NativeTypeName("Sint32")] int timeoutMS + ) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)WaitEventTimeout(__dsl_event, timeoutMS); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ) => Underlying.Value!.WaitForGPUFences(device, wait_all, fences, num_fences); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ) + { + fixed (GPUFenceHandle* __dsl_fences = fences) + { + return (MaybeBool) + (byte)WaitForGPUFences(device, (byte)wait_all, __dsl_fences, num_fences); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitForGPUIdle(GPUDeviceHandle device) => + Underlying.Value!.WaitForGPUIdle(device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitForGPUIdleRaw(GPUDeviceHandle device) => + Underlying.Value!.WaitForGPUIdleRaw(device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ) => Underlying.Value!.WaitProcess(process, block, exitcode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ) + { + fixed (int* __dsl_exitcode = exitcode) + { + return (MaybeBool)(byte)WaitProcess(process, (byte)block, __dsl_exitcode); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphore")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void WaitSemaphore(SemaphoreHandle sem) => + Underlying.Value!.WaitSemaphore(sem); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WaitSemaphoreTimeout( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ) => Underlying.Value!.WaitSemaphoreTimeout(sem, timeoutMS); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitSemaphoreTimeout")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WaitSemaphoreTimeoutRaw( + SemaphoreHandle sem, + [NativeTypeName("Sint32")] int timeoutMS + ) => Underlying.Value!.WaitSemaphoreTimeoutRaw(sem, timeoutMS); + + [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void WaitThread(ThreadHandle thread, int* status) => + Underlying.Value!.WaitThread(thread, status); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitThread")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void WaitThread(ThreadHandle thread, Ref status) + { + fixed (int* __dsl_status = status) + { + WaitThread(thread, __dsl_status); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WarpMouseGlobal(float x, float y) => + Underlying.Value!.WarpMouseGlobal(x, y); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseGlobal")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WarpMouseGlobalRaw(float x, float y) => + Underlying.Value!.WarpMouseGlobalRaw(x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_WarpMouseInWindow")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static void WarpMouseInWindow(WindowHandle window, float x, float y) => + Underlying.Value!.WarpMouseInWindow(window, x, y); + + [return: NativeTypeName("SDL_InitFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_WasInit")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => + Underlying.Value!.WasInit(flags); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => Underlying.Value!.Wcscasecmp(str1, str2); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcscasecmp(__dsl_str1, __dsl_str2); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => Underlying.Value!.Wcscmp(str1, str2); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcscmp(__dsl_str1, __dsl_str2); + } + } + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr) => + Underlying.Value!.Wcsdup(wstr); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (uint*)Wcsdup(__dsl_wstr); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcslcat(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)Wcslcat(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcslcpy(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)Wcslcpy(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr) => + Underlying.Value!.Wcslen(wstr); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)Wcslen(__dsl_wstr); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcsncasecmp(str1, str2, maxlen); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcsncasecmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcsncmp(str1, str2, maxlen); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)Wcsncmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcsnlen(wstr, maxlen); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)Wcsnlen(__dsl_wstr, maxlen); + } + } + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => Underlying.Value!.Wcsnstr(haystack, needle, maxlen); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)Wcsnstr(__dsl_haystack, __dsl_needle, maxlen); + } + } + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ) => Underlying.Value!.Wcsstr(haystack, needle); + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)Wcsstr(__dsl_haystack, __dsl_needle); + } + } + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ) => Underlying.Value!.Wcstol(str, endp, @base); + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ) + { + fixed (uint** __dsl_endp = endp) + fixed (uint* __dsl_str = str) + { + return (nint)Wcstol(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WindowHasSurface(WindowHandle window) => + Underlying.Value!.WindowHasSurface(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowHasSurface")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WindowHasSurfaceRaw(WindowHandle window) => + Underlying.Value!.WindowHasSurfaceRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => Underlying.Value!.WindowSupportsGPUPresentMode(device, window, present_mode); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => Underlying.Value!.WindowSupportsGPUPresentModeRaw(device, window, present_mode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => + Underlying.Value!.WindowSupportsGPUSwapchainComposition( + device, + window, + swapchain_composition + ); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => + Underlying.Value!.WindowSupportsGPUSwapchainCompositionRaw( + device, + window, + swapchain_composition + ); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] void* ptr, + [NativeTypeName("size_t")] nuint size + ) => Underlying.Value!.WriteIO(context, ptr, size); + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteIO")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static nuint WriteIO( + IOStreamHandle context, + [NativeTypeName("const void *")] Ref ptr, + [NativeTypeName("size_t")] nuint size + ) + { + fixed (void* __dsl_ptr = ptr) + { + return (nuint)WriteIO(context, __dsl_ptr, size); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS16BE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.WriteS16BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS16BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.WriteS16BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS16LE( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.WriteS16LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS16LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint16")] short value + ) => Underlying.Value!.WriteS16LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS32BE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => Underlying.Value!.WriteS32BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS32BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => Underlying.Value!.WriteS32BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS32LE( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => Underlying.Value!.WriteS32LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS32LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint32")] int value + ) => Underlying.Value!.WriteS32LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS64BE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => Underlying.Value!.WriteS64BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS64BERaw( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => Underlying.Value!.WriteS64BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS64LE( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => Underlying.Value!.WriteS64LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS64LERaw( + IOStreamHandle dst, + [NativeTypeName("Sint64")] long value + ) => Underlying.Value!.WriteS64LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteS8( + IOStreamHandle dst, + [NativeTypeName("Sint8")] sbyte value + ) => Underlying.Value!.WriteS8(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteS8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteS8Raw(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => + Underlying.Value!.WriteS8Raw(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const void *")] void* source, + [NativeTypeName("Uint64")] ulong length + ) => Underlying.Value!.WriteStorageFile(storage, path, source, length); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteStorageFile")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const void *")] Ref source, + [NativeTypeName("Uint64")] ulong length + ) + { + fixed (void* __dsl_source = source) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)WriteStorageFile(storage, __dsl_path, __dsl_source, length); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => Underlying.Value!.WriteSurfacePixel(surface, x, y, r, g, b, a); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixel")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)WriteSurfacePixel(__dsl_surface, x, y, r, g, b, a); + } + } + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteSurfacePixelFloat( + Surface* surface, + int x, + int y, + float r, + float g, + float b, + float a + ) => Underlying.Value!.WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteSurfacePixelFloat")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteSurfacePixelFloat( + Ref surface, + int x, + int y, + float r, + float g, + float b, + float a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)WriteSurfacePixelFloat(__dsl_surface, x, y, r, g, b, a); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU16BE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => Underlying.Value!.WriteU16BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU16BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => Underlying.Value!.WriteU16BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU16LE( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => Underlying.Value!.WriteU16LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU16LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU16LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint16")] ushort value + ) => Underlying.Value!.WriteU16LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU32BE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => Underlying.Value!.WriteU32BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU32BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => Underlying.Value!.WriteU32BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU32LE( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => Underlying.Value!.WriteU32LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU32LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU32LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint32")] uint value + ) => Underlying.Value!.WriteU32LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU64BE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => Underlying.Value!.WriteU64BE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64BE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU64BERaw( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => Underlying.Value!.WriteU64BERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU64LE( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => Underlying.Value!.WriteU64LE(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU64LE")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU64LERaw( + IOStreamHandle dst, + [NativeTypeName("Uint64")] ulong value + ) => Underlying.Value!.WriteU64LERaw(dst, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static MaybeBool WriteU8( + IOStreamHandle dst, + [NativeTypeName("Uint8")] byte value + ) => Underlying.Value!.WriteU8(dst, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WriteU8")] + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + public static byte WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => + Underlying.Value!.WriteU8Raw(dst, value); + } + + [NativeTypeName("#define SDL_MAX_SINT8 ((Sint8)0x7F)")] + public const sbyte MaxSint8 = ((sbyte)(0x7F)); + + [NativeTypeName("#define SDL_MIN_SINT8 ((Sint8)(~0x7F))")] + public const sbyte MinSint8 = ((sbyte)(~0x7F)); + + [NativeTypeName("#define SDL_MAX_UINT8 ((Uint8)0xFF)")] + public const byte MaxUint8 = ((byte)(0xFF)); + + [NativeTypeName("#define SDL_MIN_UINT8 ((Uint8)0x00)")] + public const byte MinUint8 = ((byte)(0x00)); + + [NativeTypeName("#define SDL_MAX_SINT16 ((Sint16)0x7FFF)")] + public const short MaxSint16 = ((short)(0x7FFF)); + + [NativeTypeName("#define SDL_MIN_SINT16 ((Sint16)(~0x7FFF))")] + public const short MinSint16 = ((short)(~0x7FFF)); + + [NativeTypeName("#define SDL_MAX_UINT16 ((Uint16)0xFFFF)")] + public const ushort MaxUint16 = ((ushort)(0xFFFF)); + + [NativeTypeName("#define SDL_MIN_UINT16 ((Uint16)0x0000)")] + public const ushort MinUint16 = ((ushort)(0x0000)); + + [NativeTypeName("#define SDL_MAX_SINT32 ((Sint32)0x7FFFFFFF)")] + public const int MaxSint32 = ((int)(0x7FFFFFFF)); + + [NativeTypeName("#define SDL_MIN_SINT32 ((Sint32)(~0x7FFFFFFF))")] + public const int MinSint32 = ((int)(~0x7FFFFFFF)); + + [NativeTypeName("#define SDL_MAX_UINT32 ((Uint32)0xFFFFFFFFu)")] + public const uint MaxUint32 = ((uint)(0xFFFFFFFFU)); + + [NativeTypeName("#define SDL_MIN_UINT32 ((Uint32)0x00000000)")] + public const uint MinUint32 = ((uint)(0x00000000)); + + [NativeTypeName("#define SDL_MAX_SINT64 SDL_SINT64_C(0x7FFFFFFFFFFFFFFF)")] + public const long MaxSint64 = (0x7FFFFFFFFFFFFFFFL); + + [NativeTypeName("#define SDL_MIN_SINT64 ~SDL_SINT64_C(0x7FFFFFFFFFFFFFFF)")] + public const long MinSint64 = ~(0x7FFFFFFFFFFFFFFFL); + + [NativeTypeName("#define SDL_MAX_UINT64 SDL_UINT64_C(0xFFFFFFFFFFFFFFFF)")] + public const ulong MaxUint64 = (0xFFFFFFFFFFFFFFFFUL); + + [NativeTypeName("#define SDL_MIN_UINT64 SDL_UINT64_C(0x0000000000000000)")] + public const ulong MinUint64 = (0x0000000000000000UL); + + [NativeTypeName("#define SDL_MAX_TIME SDL_MAX_SINT64")] + public const long MaxTime = (0x7FFFFFFFFFFFFFFFL); + + [NativeTypeName("#define SDL_MIN_TIME SDL_MIN_SINT64")] + public const long MinTime = ~(0x7FFFFFFFFFFFFFFFL); + + [NativeTypeName("#define SDL_FLT_EPSILON 1.1920928955078125e-07F")] + public const float FltEpsilon = 1.1920928955078125e-07F; + + [NativeTypeName("#define SDL_PRIs64 \"lld\"")] + public static Utf8String PRIs64 => "lld"u8; + + [NativeTypeName("#define SDL_PRIu64 \"llu\"")] + public static Utf8String PRIu64 => "llu"u8; + + [NativeTypeName("#define SDL_PRIx64 \"llx\"")] + public static Utf8String PRIx64 => "llx"u8; + + [NativeTypeName("#define SDL_PRIX64 \"llX\"")] + public static Utf8String Prix64 => "llX"u8; + + [NativeTypeName("#define SDL_PRIs32 \"d\"")] + public static Utf8String PRIs32 => "d"u8; + + [NativeTypeName("#define SDL_PRIu32 \"u\"")] + public static Utf8String PRIu32 => "u"u8; + + [NativeTypeName("#define SDL_PRIx32 \"x\"")] + public static Utf8String PRIx32 => "x"u8; + + [NativeTypeName("#define SDL_PRIX32 \"X\"")] + public static Utf8String Prix32 => "X"u8; + + [NativeTypeName("#define SDL_PRILL_PREFIX \"ll\"")] + public static Utf8String PrillPrefix => "ll"u8; + + [NativeTypeName("#define SDL_PRILLd SDL_PRILL_PREFIX \"d\"")] + public static Utf8String PrilLd => "lld"u8; + + [NativeTypeName("#define SDL_PRILLu SDL_PRILL_PREFIX \"u\"")] + public static Utf8String PrilLu => "llu"u8; + + [NativeTypeName("#define SDL_PRILLx SDL_PRILL_PREFIX \"x\"")] + public static Utf8String PrilLx => "llx"u8; + + [NativeTypeName("#define SDL_PRILLX SDL_PRILL_PREFIX \"X\"")] + public static Utf8String Prillx => "llX"u8; + + [NativeTypeName("#define SDL_INVALID_UNICODE_CODEPOINT 0xFFFD")] + public const int InvalidUnicodeCodepoint = 0xFFFD; + + [NativeTypeName("#define SDL_PI_D 3.141592653589793238462643383279502884")] + public const double PiD = 3.141592653589793238462643383279502884; + + [NativeTypeName("#define SDL_PI_F 3.141592653589793238462643383279502884F")] + public const float PiF = 3.141592653589793238462643383279502884F; + + [NativeTypeName("#define SDL_ICONV_ERROR (size_t)-1")] + public static nuint IconvError => unchecked((nuint)(-1)); + + [NativeTypeName("#define SDL_ICONV_E2BIG (size_t)-2")] + public static nuint IconvE2Big => unchecked((nuint)(-2)); + + [NativeTypeName("#define SDL_ICONV_EILSEQ (size_t)-3")] + public static nuint IconvEilseq => unchecked((nuint)(-3)); + + [NativeTypeName("#define SDL_ICONV_EINVAL (size_t)-4")] + public static nuint IconvEinval => unchecked((nuint)(-4)); + + [NativeTypeName("#define SDL_ASSERT_LEVEL 2")] + public const int AssertLevel = 2; + + [NativeTypeName("#define SDL_FILE __FILE__")] + public static Utf8String File => + "/Users/dylan/Documents/Silk.NET3/eng/silktouch/sdl/SDL3/sdl-SDL.h"u8; + + [NativeTypeName("#define SDL_LINE __LINE__")] + public const int Line = 89; + + [NativeTypeName("#define SDL_NULL_WHILE_LOOP_CONDITION (0)")] + public const int NullWhileLoopCondition = (0); + + [NativeTypeName( + "#define SDL_PROP_THREAD_CREATE_ENTRY_FUNCTION_POINTER \"SDL.thread.create.entry_function\"" + )] + public static Utf8String PropThreadCreateEntryFunctionPointer => + "SDL.thread.create.entry_function"u8; + + [NativeTypeName("#define SDL_PROP_THREAD_CREATE_NAME_STRING \"SDL.thread.create.name\"")] + public static Utf8String PropThreadCreateNameString => "SDL.thread.create.name"u8; + + [NativeTypeName( + "#define SDL_PROP_THREAD_CREATE_USERDATA_POINTER \"SDL.thread.create.userdata\"" + )] + public static Utf8String PropThreadCreateUserdataPointer => "SDL.thread.create.userdata"u8; + + [NativeTypeName( + "#define SDL_PROP_THREAD_CREATE_STACKSIZE_NUMBER \"SDL.thread.create.stacksize\"" + )] + public static Utf8String PropThreadCreateStacksizeNumber => "SDL.thread.create.stacksize"u8; + + [NativeTypeName( + "#define SDL_PROP_IOSTREAM_WINDOWS_HANDLE_POINTER \"SDL.iostream.windows.handle\"" + )] + public static Utf8String PropIostreamWindowsHandlePointer => "SDL.iostream.windows.handle"u8; + + [NativeTypeName("#define SDL_PROP_IOSTREAM_STDIO_FILE_POINTER \"SDL.iostream.stdio.file\"")] + public static Utf8String PropIostreamStdioFilePointer => "SDL.iostream.stdio.file"u8; + + [NativeTypeName( + "#define SDL_PROP_IOSTREAM_FILE_DESCRIPTOR_NUMBER \"SDL.iostream.file_descriptor\"" + )] + public static Utf8String PropIostreamFileDescriptorNumber => "SDL.iostream.file_descriptor"u8; + + [NativeTypeName( + "#define SDL_PROP_IOSTREAM_ANDROID_AASSET_POINTER \"SDL.iostream.android.aasset\"" + )] + public static Utf8String PropIostreamAndroidAassetPointer => "SDL.iostream.android.aasset"u8; + + [NativeTypeName("#define SDL_PROP_IOSTREAM_MEMORY_POINTER \"SDL.iostream.memory.base\"")] + public static Utf8String PropIostreamMemoryPointer => "SDL.iostream.memory.base"u8; + + [NativeTypeName("#define SDL_PROP_IOSTREAM_MEMORY_SIZE_NUMBER \"SDL.iostream.memory.size\"")] + public static Utf8String PropIostreamMemorySizeNumber => "SDL.iostream.memory.size"u8; + + [NativeTypeName( + "#define SDL_PROP_IOSTREAM_DYNAMIC_MEMORY_POINTER \"SDL.iostream.dynamic.memory\"" + )] + public static Utf8String PropIostreamDynamicMemoryPointer => "SDL.iostream.dynamic.memory"u8; + + [NativeTypeName( + "#define SDL_PROP_IOSTREAM_DYNAMIC_CHUNKSIZE_NUMBER \"SDL.iostream.dynamic.chunksize\"" + )] + public static Utf8String PropIostreamDynamicChunksizeNumber => + "SDL.iostream.dynamic.chunksize"u8; + + [NativeTypeName("#define SDL_AUDIO_MASK_BITSIZE (0xFFu)")] + public const uint AudioMaskBitsize = (0xFFU); + + [NativeTypeName("#define SDL_AUDIO_MASK_FLOAT (1u<<8)")] + public const uint AudioMaskFloat = (1U << 8); + + [NativeTypeName("#define SDL_AUDIO_MASK_BIG_ENDIAN (1u<<12)")] + public const uint AudioMaskBigEndian = (1U << 12); + + [NativeTypeName("#define SDL_AUDIO_MASK_SIGNED (1u<<15)")] + public const uint AudioMaskSigned = (1U << 15); + + [NativeTypeName("#define SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK ((SDL_AudioDeviceID) 0xFFFFFFFFu)")] + public const uint AudioDeviceDefaultPlayback = ((uint)(0xFFFFFFFFU)); + + [NativeTypeName("#define SDL_AUDIO_DEVICE_DEFAULT_RECORDING ((SDL_AudioDeviceID) 0xFFFFFFFEu)")] + public const uint AudioDeviceDefaultRecording = ((uint)(0xFFFFFFFEU)); + + [NativeTypeName("#define SDL_ALPHA_OPAQUE 255")] + public const int AlphaOpaque = 255; + + [NativeTypeName("#define SDL_ALPHA_OPAQUE_FLOAT 1.0f")] + public const float AlphaOpaqueFloat = 1.0f; + + [NativeTypeName("#define SDL_ALPHA_TRANSPARENT 0")] + public const int AlphaTransparent = 0; + + [NativeTypeName("#define SDL_ALPHA_TRANSPARENT_FLOAT 0.0f")] + public const float AlphaTransparentFloat = 0.0f; + + [NativeTypeName("#define SDL_SURFACE_PREALLOCATED 0x00000001u")] + public const uint SurfacePreallocated = 0x00000001U; + + [NativeTypeName("#define SDL_SURFACE_LOCK_NEEDED 0x00000002u")] + public const uint SurfaceLockNeeded = 0x00000002U; + + [NativeTypeName("#define SDL_SURFACE_LOCKED 0x00000004u")] + public const uint SurfaceLocked = 0x00000004U; + + [NativeTypeName("#define SDL_SURFACE_SIMD_ALIGNED 0x00000008u")] + public const uint SurfaceSimdAligned = 0x00000008U; + + [NativeTypeName( + "#define SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT \"SDL.surface.SDR_white_point\"" + )] + public static Utf8String PropSurfaceSdrWhitePointFloat => "SDL.surface.SDR_white_point"u8; + + [NativeTypeName("#define SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT \"SDL.surface.HDR_headroom\"")] + public static Utf8String PropSurfaceHdrHeadroomFloat => "SDL.surface.HDR_headroom"u8; + + [NativeTypeName("#define SDL_PROP_SURFACE_TONEMAP_OPERATOR_STRING \"SDL.surface.tonemap\"")] + public static Utf8String PropSurfaceTonemapOperatorString => "SDL.surface.tonemap"u8; + + [NativeTypeName("#define SDL_CACHELINE_SIZE 128")] + public const int CachelineSize = 128; + + [NativeTypeName( + "#define SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER \"SDL.video.wayland.wl_display\"" + )] + public static Utf8String PropGlobalVideoWaylandWlDisplayPointer => + "SDL.video.wayland.wl_display"u8; + + [NativeTypeName("#define SDL_WINDOW_FULLSCREEN SDL_UINT64_C(0x0000000000000001)")] + public const ulong WindowFullscreen = (0x0000000000000001UL); + + [NativeTypeName("#define SDL_WINDOW_OPENGL SDL_UINT64_C(0x0000000000000002)")] + public const ulong WindowOpengl = (0x0000000000000002UL); + + [NativeTypeName("#define SDL_WINDOW_OCCLUDED SDL_UINT64_C(0x0000000000000004)")] + public const ulong WindowOccluded = (0x0000000000000004UL); + + [NativeTypeName("#define SDL_WINDOW_HIDDEN SDL_UINT64_C(0x0000000000000008)")] + public const ulong WindowHidden = (0x0000000000000008UL); + + [NativeTypeName("#define SDL_WINDOW_BORDERLESS SDL_UINT64_C(0x0000000000000010)")] + public const ulong WindowBorderless = (0x0000000000000010UL); + + [NativeTypeName("#define SDL_WINDOW_RESIZABLE SDL_UINT64_C(0x0000000000000020)")] + public const ulong WindowResizable = (0x0000000000000020UL); + + [NativeTypeName("#define SDL_WINDOW_MINIMIZED SDL_UINT64_C(0x0000000000000040)")] + public const ulong WindowMinimized = (0x0000000000000040UL); + + [NativeTypeName("#define SDL_WINDOW_MAXIMIZED SDL_UINT64_C(0x0000000000000080)")] + public const ulong WindowMaximized = (0x0000000000000080UL); + + [NativeTypeName("#define SDL_WINDOW_MOUSE_GRABBED SDL_UINT64_C(0x0000000000000100)")] + public const ulong WindowMouseGrabbed = (0x0000000000000100UL); + + [NativeTypeName("#define SDL_WINDOW_INPUT_FOCUS SDL_UINT64_C(0x0000000000000200)")] + public const ulong WindowInputFocus = (0x0000000000000200UL); + + [NativeTypeName("#define SDL_WINDOW_MOUSE_FOCUS SDL_UINT64_C(0x0000000000000400)")] + public const ulong WindowMouseFocus = (0x0000000000000400UL); + + [NativeTypeName("#define SDL_WINDOW_EXTERNAL SDL_UINT64_C(0x0000000000000800)")] + public const ulong WindowExternal = (0x0000000000000800UL); + + [NativeTypeName("#define SDL_WINDOW_MODAL SDL_UINT64_C(0x0000000000001000)")] + public const ulong WindowModal = (0x0000000000001000UL); + + [NativeTypeName("#define SDL_WINDOW_HIGH_PIXEL_DENSITY SDL_UINT64_C(0x0000000000002000)")] + public const ulong WindowHighPixelDensity = (0x0000000000002000UL); + + [NativeTypeName("#define SDL_WINDOW_MOUSE_CAPTURE SDL_UINT64_C(0x0000000000004000)")] + public const ulong WindowMouseCapture = (0x0000000000004000UL); + + [NativeTypeName("#define SDL_WINDOW_MOUSE_RELATIVE_MODE SDL_UINT64_C(0x0000000000008000)")] + public const ulong WindowMouseRelativeMode = (0x0000000000008000UL); + + [NativeTypeName("#define SDL_WINDOW_ALWAYS_ON_TOP SDL_UINT64_C(0x0000000000010000)")] + public const ulong WindowAlwaysOnTop = (0x0000000000010000UL); + + [NativeTypeName("#define SDL_WINDOW_UTILITY SDL_UINT64_C(0x0000000000020000)")] + public const ulong WindowUtility = (0x0000000000020000UL); + + [NativeTypeName("#define SDL_WINDOW_TOOLTIP SDL_UINT64_C(0x0000000000040000)")] + public const ulong WindowTooltip = (0x0000000000040000UL); + + [NativeTypeName("#define SDL_WINDOW_POPUP_MENU SDL_UINT64_C(0x0000000000080000)")] + public const ulong WindowPopupMenu = (0x0000000000080000UL); + + [NativeTypeName("#define SDL_WINDOW_KEYBOARD_GRABBED SDL_UINT64_C(0x0000000000100000)")] + public const ulong WindowKeyboardGrabbed = (0x0000000000100000UL); + + [NativeTypeName("#define SDL_WINDOW_VULKAN SDL_UINT64_C(0x0000000010000000)")] + public const ulong WindowVulkan = (0x0000000010000000UL); + + [NativeTypeName("#define SDL_WINDOW_METAL SDL_UINT64_C(0x0000000020000000)")] + public const ulong WindowMetal = (0x0000000020000000UL); + + [NativeTypeName("#define SDL_WINDOW_TRANSPARENT SDL_UINT64_C(0x0000000040000000)")] + public const ulong WindowTransparent = (0x0000000040000000UL); + + [NativeTypeName("#define SDL_WINDOW_NOT_FOCUSABLE SDL_UINT64_C(0x0000000080000000)")] + public const ulong WindowNotFocusable = (0x0000000080000000UL); + + [NativeTypeName("#define SDL_WINDOWPOS_UNDEFINED_MASK 0x1FFF0000u")] + public const uint WindowposUndefinedMask = 0x1FFF0000U; + + [NativeTypeName("#define SDL_WINDOWPOS_UNDEFINED SDL_WINDOWPOS_UNDEFINED_DISPLAY(0)")] + public const uint WindowposUndefined = (0x1FFF0000U | (0)); + + [NativeTypeName("#define SDL_WINDOWPOS_CENTERED_MASK 0x2FFF0000u")] + public const uint WindowposCenteredMask = 0x2FFF0000U; + + [NativeTypeName("#define SDL_WINDOWPOS_CENTERED SDL_WINDOWPOS_CENTERED_DISPLAY(0)")] + public const uint WindowposCentered = (0x2FFF0000U | (0)); + + [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_CORE 0x0001")] + public const int GlContextProfileCore = 0x0001; + + [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_COMPATIBILITY 0x0002")] + public const int GlContextProfileCompatibility = 0x0002; + + [NativeTypeName("#define SDL_GL_CONTEXT_PROFILE_ES 0x0004")] + public const int GlContextProfileEs = 0x0004; + + [NativeTypeName("#define SDL_GL_CONTEXT_DEBUG_FLAG 0x0001")] + public const int GlContextDebugFlag = 0x0001; + + [NativeTypeName("#define SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG 0x0002")] + public const int GlContextForwardCompatibleFlag = 0x0002; + + [NativeTypeName("#define SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG 0x0004")] + public const int GlContextRobustAccessFlag = 0x0004; + + [NativeTypeName("#define SDL_GL_CONTEXT_RESET_ISOLATION_FLAG 0x0008")] + public const int GlContextResetIsolationFlag = 0x0008; + + [NativeTypeName("#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE 0x0000")] + public const int GlContextReleaseBehaviorNone = 0x0000; + + [NativeTypeName("#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x0001")] + public const int GlContextReleaseBehaviorFlush = 0x0001; + + [NativeTypeName("#define SDL_GL_CONTEXT_RESET_NO_NOTIFICATION 0x0000")] + public const int GlContextResetNoNotification = 0x0000; + + [NativeTypeName("#define SDL_GL_CONTEXT_RESET_LOSE_CONTEXT 0x0001")] + public const int GlContextResetLoseContext = 0x0001; + + [NativeTypeName("#define SDL_PROP_DISPLAY_HDR_ENABLED_BOOLEAN \"SDL.display.HDR_enabled\"")] + public static Utf8String PropDisplayHdrEnabledBoolean => "SDL.display.HDR_enabled"u8; + + [NativeTypeName( + "#define SDL_PROP_DISPLAY_KMSDRM_PANEL_ORIENTATION_NUMBER \"SDL.display.KMSDRM.panel_orientation\"" + )] + public static Utf8String PropDisplayKmsdrmPanelOrientationNumber => + "SDL.display.KMSDRM.panel_orientation"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN \"SDL.window.create.always_on_top\"" + )] + public static Utf8String PropWindowCreateAlwaysOnTopBoolean => + "SDL.window.create.always_on_top"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN \"SDL.window.create.borderless\"" + )] + public static Utf8String PropWindowCreateBorderlessBoolean => "SDL.window.create.borderless"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN \"SDL.window.create.focusable\"" + )] + public static Utf8String PropWindowCreateFocusableBoolean => "SDL.window.create.focusable"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN \"SDL.window.create.external_graphics_context\"" + )] + public static Utf8String PropWindowCreateExternalGraphicsContextBoolean => + "SDL.window.create.external_graphics_context"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER \"SDL.window.create.flags\"")] + public static Utf8String PropWindowCreateFlagsNumber => "SDL.window.create.flags"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN \"SDL.window.create.fullscreen\"" + )] + public static Utf8String PropWindowCreateFullscreenBoolean => "SDL.window.create.fullscreen"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER \"SDL.window.create.height\"")] + public static Utf8String PropWindowCreateHeightNumber => "SDL.window.create.height"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN \"SDL.window.create.hidden\"")] + public static Utf8String PropWindowCreateHiddenBoolean => "SDL.window.create.hidden"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN \"SDL.window.create.high_pixel_density\"" + )] + public static Utf8String PropWindowCreateHighPixelDensityBoolean => + "SDL.window.create.high_pixel_density"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN \"SDL.window.create.maximized\"" + )] + public static Utf8String PropWindowCreateMaximizedBoolean => "SDL.window.create.maximized"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN \"SDL.window.create.menu\"")] + public static Utf8String PropWindowCreateMenuBoolean => "SDL.window.create.menu"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN \"SDL.window.create.metal\"")] + public static Utf8String PropWindowCreateMetalBoolean => "SDL.window.create.metal"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN \"SDL.window.create.minimized\"" + )] + public static Utf8String PropWindowCreateMinimizedBoolean => "SDL.window.create.minimized"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN \"SDL.window.create.modal\"")] + public static Utf8String PropWindowCreateModalBoolean => "SDL.window.create.modal"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN \"SDL.window.create.mouse_grabbed\"" + )] + public static Utf8String PropWindowCreateMouseGrabbedBoolean => + "SDL.window.create.mouse_grabbed"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN \"SDL.window.create.opengl\"")] + public static Utf8String PropWindowCreateOpenglBoolean => "SDL.window.create.opengl"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_PARENT_POINTER \"SDL.window.create.parent\"")] + public static Utf8String PropWindowCreateParentPointer => "SDL.window.create.parent"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN \"SDL.window.create.resizable\"" + )] + public static Utf8String PropWindowCreateResizableBoolean => "SDL.window.create.resizable"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_TITLE_STRING \"SDL.window.create.title\"")] + public static Utf8String PropWindowCreateTitleString => "SDL.window.create.title"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN \"SDL.window.create.transparent\"" + )] + public static Utf8String PropWindowCreateTransparentBoolean => + "SDL.window.create.transparent"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN \"SDL.window.create.tooltip\"")] + public static Utf8String PropWindowCreateTooltipBoolean => "SDL.window.create.tooltip"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN \"SDL.window.create.utility\"")] + public static Utf8String PropWindowCreateUtilityBoolean => "SDL.window.create.utility"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN \"SDL.window.create.vulkan\"")] + public static Utf8String PropWindowCreateVulkanBoolean => "SDL.window.create.vulkan"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER \"SDL.window.create.width\"")] + public static Utf8String PropWindowCreateWidthNumber => "SDL.window.create.width"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_X_NUMBER \"SDL.window.create.x\"")] + public static Utf8String PropWindowCreateXNumber => "SDL.window.create.x"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_CREATE_Y_NUMBER \"SDL.window.create.y\"")] + public static Utf8String PropWindowCreateYNumber => "SDL.window.create.y"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER \"SDL.window.create.cocoa.window\"" + )] + public static Utf8String PropWindowCreateCocoaWindowPointer => + "SDL.window.create.cocoa.window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER \"SDL.window.create.cocoa.view\"" + )] + public static Utf8String PropWindowCreateCocoaViewPointer => "SDL.window.create.cocoa.view"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN \"SDL.window.create.wayland.surface_role_custom\"" + )] + public static Utf8String PropWindowCreateWaylandSurfaceRoleCustomBoolean => + "SDL.window.create.wayland.surface_role_custom"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN \"SDL.window.create.wayland.create_egl_window\"" + )] + public static Utf8String PropWindowCreateWaylandCreateEglWindowBoolean => + "SDL.window.create.wayland.create_egl_window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER \"SDL.window.create.wayland.wl_surface\"" + )] + public static Utf8String PropWindowCreateWaylandWlSurfacePointer => + "SDL.window.create.wayland.wl_surface"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER \"SDL.window.create.win32.hwnd\"" + )] + public static Utf8String PropWindowCreateWin32HwndPointer => "SDL.window.create.win32.hwnd"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER \"SDL.window.create.win32.pixel_format_hwnd\"" + )] + public static Utf8String PropWindowCreateWin32PixelFormatHwndPointer => + "SDL.window.create.win32.pixel_format_hwnd"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER \"SDL.window.create.x11.window\"" + )] + public static Utf8String PropWindowCreateX11WindowNumber => "SDL.window.create.x11.window"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_SHAPE_POINTER \"SDL.window.shape\"")] + public static Utf8String PropWindowShapePointer => "SDL.window.shape"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_HDR_ENABLED_BOOLEAN \"SDL.window.HDR_enabled\"")] + public static Utf8String PropWindowHdrEnabledBoolean => "SDL.window.HDR_enabled"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_SDR_WHITE_LEVEL_FLOAT \"SDL.window.SDR_white_level\"")] + public static Utf8String PropWindowSdrWhiteLevelFloat => "SDL.window.SDR_white_level"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_HDR_HEADROOM_FLOAT \"SDL.window.HDR_headroom\"")] + public static Utf8String PropWindowHdrHeadroomFloat => "SDL.window.HDR_headroom"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_ANDROID_WINDOW_POINTER \"SDL.window.android.window\"")] + public static Utf8String PropWindowAndroidWindowPointer => "SDL.window.android.window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_ANDROID_SURFACE_POINTER \"SDL.window.android.surface\"" + )] + public static Utf8String PropWindowAndroidSurfacePointer => "SDL.window.android.surface"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER \"SDL.window.uikit.window\"")] + public static Utf8String PropWindowUikitWindowPointer => "SDL.window.uikit.window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER \"SDL.window.uikit.metal_view_tag\"" + )] + public static Utf8String PropWindowUikitMetalViewTagNumber => + "SDL.window.uikit.metal_view_tag"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_UIKIT_OPENGL_FRAMEBUFFER_NUMBER \"SDL.window.uikit.opengl.framebuffer\"" + )] + public static Utf8String PropWindowUikitOpenglFramebufferNumber => + "SDL.window.uikit.opengl.framebuffer"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_UIKIT_OPENGL_RENDERBUFFER_NUMBER \"SDL.window.uikit.opengl.renderbuffer\"" + )] + public static Utf8String PropWindowUikitOpenglRenderbufferNumber => + "SDL.window.uikit.opengl.renderbuffer"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_UIKIT_OPENGL_RESOLVE_FRAMEBUFFER_NUMBER \"SDL.window.uikit.opengl.resolve_framebuffer\"" + )] + public static Utf8String PropWindowUikitOpenglResolveFramebufferNumber => + "SDL.window.uikit.opengl.resolve_framebuffer"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER \"SDL.window.kmsdrm.dev_index\"" + )] + public static Utf8String PropWindowKmsdrmDeviceIndexNumber => "SDL.window.kmsdrm.dev_index"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_KMSDRM_DRM_FD_NUMBER \"SDL.window.kmsdrm.drm_fd\"")] + public static Utf8String PropWindowKmsdrmDrmFdNumber => "SDL.window.kmsdrm.drm_fd"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER \"SDL.window.kmsdrm.gbm_dev\"" + )] + public static Utf8String PropWindowKmsdrmGbmDevicePointer => "SDL.window.kmsdrm.gbm_dev"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_COCOA_WINDOW_POINTER \"SDL.window.cocoa.window\"")] + public static Utf8String PropWindowCocoaWindowPointer => "SDL.window.cocoa.window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER \"SDL.window.cocoa.metal_view_tag\"" + )] + public static Utf8String PropWindowCocoaMetalViewTagNumber => + "SDL.window.cocoa.metal_view_tag"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_OPENVR_OVERLAY_ID \"SDL.window.openvr.overlay_id\"")] + public static Utf8String PropWindowOpenvrOverlayId => "SDL.window.openvr.overlay_id"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER \"SDL.window.vivante.display\"" + )] + public static Utf8String PropWindowVivanteDisplayPointer => "SDL.window.vivante.display"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER \"SDL.window.vivante.window\"")] + public static Utf8String PropWindowVivanteWindowPointer => "SDL.window.vivante.window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER \"SDL.window.vivante.surface\"" + )] + public static Utf8String PropWindowVivanteSurfacePointer => "SDL.window.vivante.surface"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_HWND_POINTER \"SDL.window.win32.hwnd\"")] + public static Utf8String PropWindowWin32HwndPointer => "SDL.window.win32.hwnd"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_HDC_POINTER \"SDL.window.win32.hdc\"")] + public static Utf8String PropWindowWin32HdcPointer => "SDL.window.win32.hdc"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER \"SDL.window.win32.instance\"")] + public static Utf8String PropWindowWin32InstancePointer => "SDL.window.win32.instance"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER \"SDL.window.wayland.display\"" + )] + public static Utf8String PropWindowWaylandDisplayPointer => "SDL.window.wayland.display"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER \"SDL.window.wayland.surface\"" + )] + public static Utf8String PropWindowWaylandSurfacePointer => "SDL.window.wayland.surface"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_EGL_WINDOW_POINTER \"SDL.window.wayland.egl_window\"" + )] + public static Utf8String PropWindowWaylandEglWindowPointer => "SDL.window.wayland.egl_window"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_XDG_SURFACE_POINTER \"SDL.window.wayland.xdg_surface\"" + )] + public static Utf8String PropWindowWaylandXdgSurfacePointer => + "SDL.window.wayland.xdg_surface"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER \"SDL.window.wayland.xdg_toplevel\"" + )] + public static Utf8String PropWindowWaylandXdgToplevelPointer => + "SDL.window.wayland.xdg_toplevel"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING \"SDL.window.wayland.xdg_toplevel_export_handle\"" + )] + public static Utf8String PropWindowWaylandXdgToplevelExportHandleString => + "SDL.window.wayland.xdg_toplevel_export_handle"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_XDG_POPUP_POINTER \"SDL.window.wayland.xdg_popup\"" + )] + public static Utf8String PropWindowWaylandXdgPopupPointer => "SDL.window.wayland.xdg_popup"u8; + + [NativeTypeName( + "#define SDL_PROP_WINDOW_WAYLAND_XDG_POSITIONER_POINTER \"SDL.window.wayland.xdg_positioner\"" + )] + public static Utf8String PropWindowWaylandXdgPositionerPointer => + "SDL.window.wayland.xdg_positioner"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_X11_DISPLAY_POINTER \"SDL.window.x11.display\"")] + public static Utf8String PropWindowX11DisplayPointer => "SDL.window.x11.display"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_X11_SCREEN_NUMBER \"SDL.window.x11.screen\"")] + public static Utf8String PropWindowX11ScreenNumber => "SDL.window.x11.screen"u8; + + [NativeTypeName("#define SDL_PROP_WINDOW_X11_WINDOW_NUMBER \"SDL.window.x11.window\"")] + public static Utf8String PropWindowX11WindowNumber => "SDL.window.x11.window"u8; + + [NativeTypeName("#define SDL_WINDOW_SURFACE_VSYNC_DISABLED 0")] + public const int WindowSurfaceVsyncDisabled = 0; + + [NativeTypeName("#define SDL_WINDOW_SURFACE_VSYNC_ADAPTIVE (-1)")] + public const int WindowSurfaceVsyncAdaptive = (-1); + + [NativeTypeName("#define SDL_STANDARD_GRAVITY 9.80665f")] + public const float StandardGravity = 9.80665f; + + [NativeTypeName("#define SDL_JOYSTICK_AXIS_MAX 32767")] + public const int JoystickAxisMax = 32767; + + [NativeTypeName("#define SDL_JOYSTICK_AXIS_MIN -32768")] + public const int JoystickAxisMin = -32768; + + [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN \"SDL.joystick.cap.mono_led\"")] + public static Utf8String PropJoystickCapMonoLedBoolean => "SDL.joystick.cap.mono_led"u8; + + [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN \"SDL.joystick.cap.rgb_led\"")] + public static Utf8String PropJoystickCapRgbLedBoolean => "SDL.joystick.cap.rgb_led"u8; + + [NativeTypeName( + "#define SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN \"SDL.joystick.cap.player_led\"" + )] + public static Utf8String PropJoystickCapPlayerLedBoolean => "SDL.joystick.cap.player_led"u8; + + [NativeTypeName("#define SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN \"SDL.joystick.cap.rumble\"")] + public static Utf8String PropJoystickCapRumbleBoolean => "SDL.joystick.cap.rumble"u8; + + [NativeTypeName( + "#define SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN \"SDL.joystick.cap.trigger_rumble\"" + )] + public static Utf8String PropJoystickCapTriggerRumbleBoolean => + "SDL.joystick.cap.trigger_rumble"u8; + + [NativeTypeName("#define SDL_HAT_CENTERED 0x00u")] + public const uint HatCentered = 0x00U; + + [NativeTypeName("#define SDL_HAT_UP 0x01u")] + public const uint HatUp = 0x01U; + + [NativeTypeName("#define SDL_HAT_RIGHT 0x02u")] + public const uint HatRight = 0x02U; + + [NativeTypeName("#define SDL_HAT_DOWN 0x04u")] + public const uint HatDown = 0x04U; + + [NativeTypeName("#define SDL_HAT_LEFT 0x08u")] + public const uint HatLeft = 0x08U; + + [NativeTypeName("#define SDL_HAT_RIGHTUP (SDL_HAT_RIGHT|SDL_HAT_UP)")] + public const uint HatRightup = (0x02U | 0x01U); + + [NativeTypeName("#define SDL_HAT_RIGHTDOWN (SDL_HAT_RIGHT|SDL_HAT_DOWN)")] + public const uint HatRightdown = (0x02U | 0x04U); + + [NativeTypeName("#define SDL_HAT_LEFTUP (SDL_HAT_LEFT|SDL_HAT_UP)")] + public const uint HatLeftup = (0x08U | 0x01U); + + [NativeTypeName("#define SDL_HAT_LEFTDOWN (SDL_HAT_LEFT|SDL_HAT_DOWN)")] + public const uint HatLeftdown = (0x08U | 0x04U); + + [NativeTypeName( + "#define SDL_PROP_GAMEPAD_CAP_MONO_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN" + )] + public static Utf8String PropGamepadCapMonoLedBoolean => "SDL.joystick.cap.mono_led"u8; + + [NativeTypeName( + "#define SDL_PROP_GAMEPAD_CAP_RGB_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN" + )] + public static Utf8String PropGamepadCapRgbLedBoolean => "SDL.joystick.cap.rgb_led"u8; + + [NativeTypeName( + "#define SDL_PROP_GAMEPAD_CAP_PLAYER_LED_BOOLEAN SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN" + )] + public static Utf8String PropGamepadCapPlayerLedBoolean => "SDL.joystick.cap.player_led"u8; + + [NativeTypeName( + "#define SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN" + )] + public static Utf8String PropGamepadCapRumbleBoolean => "SDL.joystick.cap.rumble"u8; + + [NativeTypeName( + "#define SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN" + )] + public static Utf8String PropGamepadCapTriggerRumbleBoolean => + "SDL.joystick.cap.trigger_rumble"u8; + + [NativeTypeName("#define SDLK_SCANCODE_MASK (1u<<30)")] + public const uint KScancodeMask = (1U << 30); + + [NativeTypeName("#define SDLK_UNKNOWN 0x00000000u")] + public const uint KUnknown = 0x00000000U; + + [NativeTypeName("#define SDLK_RETURN 0x0000000du")] + public const uint KReturn = 0x0000000dU; + + [NativeTypeName("#define SDLK_ESCAPE 0x0000001bu")] + public const uint KEscape = 0x0000001bU; + + [NativeTypeName("#define SDLK_BACKSPACE 0x00000008u")] + public const uint KBackspace = 0x00000008U; + + [NativeTypeName("#define SDLK_TAB 0x00000009u")] + public const uint KTab = 0x00000009U; + + [NativeTypeName("#define SDLK_SPACE 0x00000020u")] + public const uint KSpace = 0x00000020U; + + [NativeTypeName("#define SDLK_EXCLAIM 0x00000021u")] + public const uint KExclaim = 0x00000021U; + + [NativeTypeName("#define SDLK_DBLAPOSTROPHE 0x00000022u")] + public const uint KDblapostrophe = 0x00000022U; + + [NativeTypeName("#define SDLK_HASH 0x00000023u")] + public const uint KHash = 0x00000023U; + + [NativeTypeName("#define SDLK_DOLLAR 0x00000024u")] + public const uint KDollar = 0x00000024U; + + [NativeTypeName("#define SDLK_PERCENT 0x00000025u")] + public const uint KPercent = 0x00000025U; + + [NativeTypeName("#define SDLK_AMPERSAND 0x00000026u")] + public const uint KAmpersand = 0x00000026U; + + [NativeTypeName("#define SDLK_APOSTROPHE 0x00000027u")] + public const uint KApostrophe = 0x00000027U; + + [NativeTypeName("#define SDLK_LEFTPAREN 0x00000028u")] + public const uint KLeftparen = 0x00000028U; + + [NativeTypeName("#define SDLK_RIGHTPAREN 0x00000029u")] + public const uint KRightparen = 0x00000029U; + + [NativeTypeName("#define SDLK_ASTERISK 0x0000002au")] + public const uint KAsterisk = 0x0000002aU; + + [NativeTypeName("#define SDLK_PLUS 0x0000002bu")] + public const uint KPlus = 0x0000002bU; + + [NativeTypeName("#define SDLK_COMMA 0x0000002cu")] + public const uint KComma = 0x0000002cU; + + [NativeTypeName("#define SDLK_MINUS 0x0000002du")] + public const uint KMinus = 0x0000002dU; + + [NativeTypeName("#define SDLK_PERIOD 0x0000002eu")] + public const uint KPeriod = 0x0000002eU; + + [NativeTypeName("#define SDLK_SLASH 0x0000002fu")] + public const uint KSlash = 0x0000002fU; + + [NativeTypeName("#define SDLK_0 0x00000030u")] + public const uint K0 = 0x00000030U; + + [NativeTypeName("#define SDLK_1 0x00000031u")] + public const uint K1 = 0x00000031U; + + [NativeTypeName("#define SDLK_2 0x00000032u")] + public const uint K2 = 0x00000032U; + + [NativeTypeName("#define SDLK_3 0x00000033u")] + public const uint K3 = 0x00000033U; + + [NativeTypeName("#define SDLK_4 0x00000034u")] + public const uint K4 = 0x00000034U; + + [NativeTypeName("#define SDLK_5 0x00000035u")] + public const uint K5 = 0x00000035U; + + [NativeTypeName("#define SDLK_6 0x00000036u")] + public const uint K6 = 0x00000036U; + + [NativeTypeName("#define SDLK_7 0x00000037u")] + public const uint K7 = 0x00000037U; + + [NativeTypeName("#define SDLK_8 0x00000038u")] + public const uint K8 = 0x00000038U; + + [NativeTypeName("#define SDLK_9 0x00000039u")] + public const uint K9 = 0x00000039U; + + [NativeTypeName("#define SDLK_COLON 0x0000003au")] + public const uint KColon = 0x0000003aU; + + [NativeTypeName("#define SDLK_SEMICOLON 0x0000003bu")] + public const uint KSemicolon = 0x0000003bU; + + [NativeTypeName("#define SDLK_LESS 0x0000003cu")] + public const uint KLess = 0x0000003cU; + + [NativeTypeName("#define SDLK_EQUALS 0x0000003du")] + public const uint KEquals = 0x0000003dU; + + [NativeTypeName("#define SDLK_GREATER 0x0000003eu")] + public const uint KGreater = 0x0000003eU; + + [NativeTypeName("#define SDLK_QUESTION 0x0000003fu")] + public const uint KQuestion = 0x0000003fU; + + [NativeTypeName("#define SDLK_AT 0x00000040u")] + public const uint KAt = 0x00000040U; + + [NativeTypeName("#define SDLK_LEFTBRACKET 0x0000005bu")] + public const uint KLeftbracket = 0x0000005bU; + + [NativeTypeName("#define SDLK_BACKSLASH 0x0000005cu")] + public const uint KBackslash = 0x0000005cU; + + [NativeTypeName("#define SDLK_RIGHTBRACKET 0x0000005du")] + public const uint KRightbracket = 0x0000005dU; + + [NativeTypeName("#define SDLK_CARET 0x0000005eu")] + public const uint KCaret = 0x0000005eU; + + [NativeTypeName("#define SDLK_UNDERSCORE 0x0000005fu")] + public const uint KUnderscore = 0x0000005fU; + + [NativeTypeName("#define SDLK_GRAVE 0x00000060u")] + public const uint KGrave = 0x00000060U; + + [NativeTypeName("#define SDLK_A 0x00000061u")] + public const uint Ka = 0x00000061U; + + [NativeTypeName("#define SDLK_B 0x00000062u")] + public const uint Kb = 0x00000062U; + + [NativeTypeName("#define SDLK_C 0x00000063u")] + public const uint Kc = 0x00000063U; + + [NativeTypeName("#define SDLK_D 0x00000064u")] + public const uint Kd = 0x00000064U; + + [NativeTypeName("#define SDLK_E 0x00000065u")] + public const uint Ke = 0x00000065U; + + [NativeTypeName("#define SDLK_F 0x00000066u")] + public const uint Kf = 0x00000066U; + + [NativeTypeName("#define SDLK_G 0x00000067u")] + public const uint Kg = 0x00000067U; + + [NativeTypeName("#define SDLK_H 0x00000068u")] + public const uint Kh = 0x00000068U; + + [NativeTypeName("#define SDLK_I 0x00000069u")] + public const uint Ki = 0x00000069U; + + [NativeTypeName("#define SDLK_J 0x0000006au")] + public const uint Kj = 0x0000006aU; + + [NativeTypeName("#define SDLK_K 0x0000006bu")] + public const uint Kk = 0x0000006bU; + + [NativeTypeName("#define SDLK_L 0x0000006cu")] + public const uint Kl = 0x0000006cU; + + [NativeTypeName("#define SDLK_M 0x0000006du")] + public const uint Km = 0x0000006dU; + + [NativeTypeName("#define SDLK_N 0x0000006eu")] + public const uint Kn = 0x0000006eU; + + [NativeTypeName("#define SDLK_O 0x0000006fu")] + public const uint Ko = 0x0000006fU; + + [NativeTypeName("#define SDLK_P 0x00000070u")] + public const uint Kp = 0x00000070U; + + [NativeTypeName("#define SDLK_Q 0x00000071u")] + public const uint Kq = 0x00000071U; + + [NativeTypeName("#define SDLK_R 0x00000072u")] + public const uint Kr = 0x00000072U; + + [NativeTypeName("#define SDLK_S 0x00000073u")] + public const uint Ks = 0x00000073U; + + [NativeTypeName("#define SDLK_T 0x00000074u")] + public const uint Kt = 0x00000074U; + + [NativeTypeName("#define SDLK_U 0x00000075u")] + public const uint Ku = 0x00000075U; + + [NativeTypeName("#define SDLK_V 0x00000076u")] + public const uint Kv = 0x00000076U; + + [NativeTypeName("#define SDLK_W 0x00000077u")] + public const uint Kw = 0x00000077U; + + [NativeTypeName("#define SDLK_X 0x00000078u")] + public const uint Kx = 0x00000078U; + + [NativeTypeName("#define SDLK_Y 0x00000079u")] + public const uint Ky = 0x00000079U; + + [NativeTypeName("#define SDLK_Z 0x0000007au")] + public const uint Kz = 0x0000007aU; + + [NativeTypeName("#define SDLK_LEFTBRACE 0x0000007bu")] + public const uint KLeftbrace = 0x0000007bU; + + [NativeTypeName("#define SDLK_PIPE 0x0000007cu")] + public const uint KPipe = 0x0000007cU; + + [NativeTypeName("#define SDLK_RIGHTBRACE 0x0000007du")] + public const uint KRightbrace = 0x0000007dU; + + [NativeTypeName("#define SDLK_TILDE 0x0000007eu")] + public const uint KTilde = 0x0000007eU; + + [NativeTypeName("#define SDLK_DELETE 0x0000007fu")] + public const uint KDelete = 0x0000007fU; + + [NativeTypeName("#define SDLK_PLUSMINUS 0x000000b1u")] + public const uint KPlusminus = 0x000000b1U; + + [NativeTypeName("#define SDLK_CAPSLOCK 0x40000039u")] + public const uint KCapslock = 0x40000039U; + + [NativeTypeName("#define SDLK_F1 0x4000003au")] + public const uint KF1 = 0x4000003aU; + + [NativeTypeName("#define SDLK_F2 0x4000003bu")] + public const uint KF2 = 0x4000003bU; + + [NativeTypeName("#define SDLK_F3 0x4000003cu")] + public const uint KF3 = 0x4000003cU; + + [NativeTypeName("#define SDLK_F4 0x4000003du")] + public const uint KF4 = 0x4000003dU; + + [NativeTypeName("#define SDLK_F5 0x4000003eu")] + public const uint KF5 = 0x4000003eU; + + [NativeTypeName("#define SDLK_F6 0x4000003fu")] + public const uint KF6 = 0x4000003fU; + + [NativeTypeName("#define SDLK_F7 0x40000040u")] + public const uint KF7 = 0x40000040U; + + [NativeTypeName("#define SDLK_F8 0x40000041u")] + public const uint KF8 = 0x40000041U; + + [NativeTypeName("#define SDLK_F9 0x40000042u")] + public const uint KF9 = 0x40000042U; + + [NativeTypeName("#define SDLK_F10 0x40000043u")] + public const uint KF10 = 0x40000043U; + + [NativeTypeName("#define SDLK_F11 0x40000044u")] + public const uint KF11 = 0x40000044U; + + [NativeTypeName("#define SDLK_F12 0x40000045u")] + public const uint KF12 = 0x40000045U; + + [NativeTypeName("#define SDLK_PRINTSCREEN 0x40000046u")] + public const uint KPrintscreen = 0x40000046U; + + [NativeTypeName("#define SDLK_SCROLLLOCK 0x40000047u")] + public const uint KScrolllock = 0x40000047U; + + [NativeTypeName("#define SDLK_PAUSE 0x40000048u")] + public const uint KPause = 0x40000048U; + + [NativeTypeName("#define SDLK_INSERT 0x40000049u")] + public const uint KInsert = 0x40000049U; + + [NativeTypeName("#define SDLK_HOME 0x4000004au")] + public const uint KHome = 0x4000004aU; + + [NativeTypeName("#define SDLK_PAGEUP 0x4000004bu")] + public const uint KPageup = 0x4000004bU; + + [NativeTypeName("#define SDLK_END 0x4000004du")] + public const uint KEnd = 0x4000004dU; + + [NativeTypeName("#define SDLK_PAGEDOWN 0x4000004eu")] + public const uint KPagedown = 0x4000004eU; + + [NativeTypeName("#define SDLK_RIGHT 0x4000004fu")] + public const uint KRight = 0x4000004fU; + + [NativeTypeName("#define SDLK_LEFT 0x40000050u")] + public const uint KLeft = 0x40000050U; + + [NativeTypeName("#define SDLK_DOWN 0x40000051u")] + public const uint KDown = 0x40000051U; + + [NativeTypeName("#define SDLK_UP 0x40000052u")] + public const uint KUp = 0x40000052U; + + [NativeTypeName("#define SDLK_NUMLOCKCLEAR 0x40000053u")] + public const uint KNumlockclear = 0x40000053U; + + [NativeTypeName("#define SDLK_KP_DIVIDE 0x40000054u")] + public const uint KKpDivide = 0x40000054U; + + [NativeTypeName("#define SDLK_KP_MULTIPLY 0x40000055u")] + public const uint KKpMultiply = 0x40000055U; + + [NativeTypeName("#define SDLK_KP_MINUS 0x40000056u")] + public const uint KKpMinus = 0x40000056U; + + [NativeTypeName("#define SDLK_KP_PLUS 0x40000057u")] + public const uint KKpPlus = 0x40000057U; + + [NativeTypeName("#define SDLK_KP_ENTER 0x40000058u")] + public const uint KKpEnter = 0x40000058U; + + [NativeTypeName("#define SDLK_KP_1 0x40000059u")] + public const uint KKp1 = 0x40000059U; + + [NativeTypeName("#define SDLK_KP_2 0x4000005au")] + public const uint KKp2 = 0x4000005aU; + + [NativeTypeName("#define SDLK_KP_3 0x4000005bu")] + public const uint KKp3 = 0x4000005bU; + + [NativeTypeName("#define SDLK_KP_4 0x4000005cu")] + public const uint KKp4 = 0x4000005cU; + + [NativeTypeName("#define SDLK_KP_5 0x4000005du")] + public const uint KKp5 = 0x4000005dU; + + [NativeTypeName("#define SDLK_KP_6 0x4000005eu")] + public const uint KKp6 = 0x4000005eU; + + [NativeTypeName("#define SDLK_KP_7 0x4000005fu")] + public const uint KKp7 = 0x4000005fU; + + [NativeTypeName("#define SDLK_KP_8 0x40000060u")] + public const uint KKp8 = 0x40000060U; + + [NativeTypeName("#define SDLK_KP_9 0x40000061u")] + public const uint KKp9 = 0x40000061U; + + [NativeTypeName("#define SDLK_KP_0 0x40000062u")] + public const uint KKp0 = 0x40000062U; + + [NativeTypeName("#define SDLK_KP_PERIOD 0x40000063u")] + public const uint KKpPeriod = 0x40000063U; [NativeTypeName("#define SDLK_APPLICATION 0x40000065u")] public const uint KApplication = 0x40000065U; - [NativeTypeName("#define SDLK_POWER 0x40000066u")] - public const uint KPower = 0x40000066U; + [NativeTypeName("#define SDLK_POWER 0x40000066u")] + public const uint KPower = 0x40000066U; + + [NativeTypeName("#define SDLK_KP_EQUALS 0x40000067u")] + public const uint KKpEquals = 0x40000067U; + + [NativeTypeName("#define SDLK_F13 0x40000068u")] + public const uint KF13 = 0x40000068U; + + [NativeTypeName("#define SDLK_F14 0x40000069u")] + public const uint KF14 = 0x40000069U; + + [NativeTypeName("#define SDLK_F15 0x4000006au")] + public const uint KF15 = 0x4000006aU; + + [NativeTypeName("#define SDLK_F16 0x4000006bu")] + public const uint KF16 = 0x4000006bU; + + [NativeTypeName("#define SDLK_F17 0x4000006cu")] + public const uint KF17 = 0x4000006cU; + + [NativeTypeName("#define SDLK_F18 0x4000006du")] + public const uint KF18 = 0x4000006dU; + + [NativeTypeName("#define SDLK_F19 0x4000006eu")] + public const uint KF19 = 0x4000006eU; + + [NativeTypeName("#define SDLK_F20 0x4000006fu")] + public const uint KF20 = 0x4000006fU; + + [NativeTypeName("#define SDLK_F21 0x40000070u")] + public const uint KF21 = 0x40000070U; + + [NativeTypeName("#define SDLK_F22 0x40000071u")] + public const uint KF22 = 0x40000071U; + + [NativeTypeName("#define SDLK_F23 0x40000072u")] + public const uint KF23 = 0x40000072U; + + [NativeTypeName("#define SDLK_F24 0x40000073u")] + public const uint KF24 = 0x40000073U; + + [NativeTypeName("#define SDLK_EXECUTE 0x40000074u")] + public const uint KExecute = 0x40000074U; + + [NativeTypeName("#define SDLK_HELP 0x40000075u")] + public const uint KHelp = 0x40000075U; + + [NativeTypeName("#define SDLK_MENU 0x40000076u")] + public const uint KMenu = 0x40000076U; + + [NativeTypeName("#define SDLK_SELECT 0x40000077u")] + public const uint KSelect = 0x40000077U; + + [NativeTypeName("#define SDLK_STOP 0x40000078u")] + public const uint KStop = 0x40000078U; + + [NativeTypeName("#define SDLK_AGAIN 0x40000079u")] + public const uint KAgain = 0x40000079U; + + [NativeTypeName("#define SDLK_UNDO 0x4000007au")] + public const uint KUndo = 0x4000007aU; + + [NativeTypeName("#define SDLK_CUT 0x4000007bu")] + public const uint KCut = 0x4000007bU; + + [NativeTypeName("#define SDLK_COPY 0x4000007cu")] + public const uint KCopy = 0x4000007cU; + + [NativeTypeName("#define SDLK_PASTE 0x4000007du")] + public const uint KPaste = 0x4000007dU; + + [NativeTypeName("#define SDLK_FIND 0x4000007eu")] + public const uint KFind = 0x4000007eU; + + [NativeTypeName("#define SDLK_MUTE 0x4000007fu")] + public const uint KMute = 0x4000007fU; + + [NativeTypeName("#define SDLK_VOLUMEUP 0x40000080u")] + public const uint KVolumeup = 0x40000080U; + + [NativeTypeName("#define SDLK_VOLUMEDOWN 0x40000081u")] + public const uint KVolumedown = 0x40000081U; + + [NativeTypeName("#define SDLK_KP_COMMA 0x40000085u")] + public const uint KKpComma = 0x40000085U; + + [NativeTypeName("#define SDLK_KP_EQUALSAS400 0x40000086u")] + public const uint KKpEqualsas400 = 0x40000086U; + + [NativeTypeName("#define SDLK_ALTERASE 0x40000099u")] + public const uint KAlterase = 0x40000099U; + + [NativeTypeName("#define SDLK_SYSREQ 0x4000009au")] + public const uint KSysreq = 0x4000009aU; + + [NativeTypeName("#define SDLK_CANCEL 0x4000009bu")] + public const uint KCancel = 0x4000009bU; + + [NativeTypeName("#define SDLK_CLEAR 0x4000009cu")] + public const uint KClear = 0x4000009cU; + + [NativeTypeName("#define SDLK_PRIOR 0x4000009du")] + public const uint KPrior = 0x4000009dU; + + [NativeTypeName("#define SDLK_RETURN2 0x4000009eu")] + public const uint KReturn2 = 0x4000009eU; + + [NativeTypeName("#define SDLK_SEPARATOR 0x4000009fu")] + public const uint KSeparator = 0x4000009fU; + + [NativeTypeName("#define SDLK_OUT 0x400000a0u")] + public const uint KOut = 0x400000a0U; + + [NativeTypeName("#define SDLK_OPER 0x400000a1u")] + public const uint KOper = 0x400000a1U; + + [NativeTypeName("#define SDLK_CLEARAGAIN 0x400000a2u")] + public const uint KClearagain = 0x400000a2U; + + [NativeTypeName("#define SDLK_CRSEL 0x400000a3u")] + public const uint KCrsel = 0x400000a3U; + + [NativeTypeName("#define SDLK_EXSEL 0x400000a4u")] + public const uint KExsel = 0x400000a4U; + + [NativeTypeName("#define SDLK_KP_00 0x400000b0u")] + public const uint KKp00 = 0x400000b0U; + + [NativeTypeName("#define SDLK_KP_000 0x400000b1u")] + public const uint KKp000 = 0x400000b1U; + + [NativeTypeName("#define SDLK_THOUSANDSSEPARATOR 0x400000b2u")] + public const uint KThousandsseparator = 0x400000b2U; + + [NativeTypeName("#define SDLK_DECIMALSEPARATOR 0x400000b3u")] + public const uint KDecimalseparator = 0x400000b3U; + + [NativeTypeName("#define SDLK_CURRENCYUNIT 0x400000b4u")] + public const uint KCurrencyunit = 0x400000b4U; + + [NativeTypeName("#define SDLK_CURRENCYSUBUNIT 0x400000b5u")] + public const uint KCurrencysubunit = 0x400000b5U; + + [NativeTypeName("#define SDLK_KP_LEFTPAREN 0x400000b6u")] + public const uint KKpLeftparen = 0x400000b6U; + + [NativeTypeName("#define SDLK_KP_RIGHTPAREN 0x400000b7u")] + public const uint KKpRightparen = 0x400000b7U; + + [NativeTypeName("#define SDLK_KP_LEFTBRACE 0x400000b8u")] + public const uint KKpLeftbrace = 0x400000b8U; + + [NativeTypeName("#define SDLK_KP_RIGHTBRACE 0x400000b9u")] + public const uint KKpRightbrace = 0x400000b9U; + + [NativeTypeName("#define SDLK_KP_TAB 0x400000bau")] + public const uint KKpTab = 0x400000baU; + + [NativeTypeName("#define SDLK_KP_BACKSPACE 0x400000bbu")] + public const uint KKpBackspace = 0x400000bbU; + + [NativeTypeName("#define SDLK_KP_A 0x400000bcu")] + public const uint KKpA = 0x400000bcU; + + [NativeTypeName("#define SDLK_KP_B 0x400000bdu")] + public const uint KKpB = 0x400000bdU; + + [NativeTypeName("#define SDLK_KP_C 0x400000beu")] + public const uint KKpC = 0x400000beU; + + [NativeTypeName("#define SDLK_KP_D 0x400000bfu")] + public const uint KKpD = 0x400000bfU; + + [NativeTypeName("#define SDLK_KP_E 0x400000c0u")] + public const uint KKpE = 0x400000c0U; + + [NativeTypeName("#define SDLK_KP_F 0x400000c1u")] + public const uint KKpF = 0x400000c1U; + + [NativeTypeName("#define SDLK_KP_XOR 0x400000c2u")] + public const uint KKpXor = 0x400000c2U; + + [NativeTypeName("#define SDLK_KP_POWER 0x400000c3u")] + public const uint KKpPower = 0x400000c3U; + + [NativeTypeName("#define SDLK_KP_PERCENT 0x400000c4u")] + public const uint KKpPercent = 0x400000c4U; + + [NativeTypeName("#define SDLK_KP_LESS 0x400000c5u")] + public const uint KKpLess = 0x400000c5U; + + [NativeTypeName("#define SDLK_KP_GREATER 0x400000c6u")] + public const uint KKpGreater = 0x400000c6U; + + [NativeTypeName("#define SDLK_KP_AMPERSAND 0x400000c7u")] + public const uint KKpAmpersand = 0x400000c7U; + + [NativeTypeName("#define SDLK_KP_DBLAMPERSAND 0x400000c8u")] + public const uint KKpDblampersand = 0x400000c8U; + + [NativeTypeName("#define SDLK_KP_VERTICALBAR 0x400000c9u")] + public const uint KKpVerticalbar = 0x400000c9U; + + [NativeTypeName("#define SDLK_KP_DBLVERTICALBAR 0x400000cau")] + public const uint KKpDblverticalbar = 0x400000caU; + + [NativeTypeName("#define SDLK_KP_COLON 0x400000cbu")] + public const uint KKpColon = 0x400000cbU; + + [NativeTypeName("#define SDLK_KP_HASH 0x400000ccu")] + public const uint KKpHash = 0x400000ccU; + + [NativeTypeName("#define SDLK_KP_SPACE 0x400000cdu")] + public const uint KKpSpace = 0x400000cdU; + + [NativeTypeName("#define SDLK_KP_AT 0x400000ceu")] + public const uint KKpAt = 0x400000ceU; + + [NativeTypeName("#define SDLK_KP_EXCLAM 0x400000cfu")] + public const uint KKpExclam = 0x400000cfU; + + [NativeTypeName("#define SDLK_KP_MEMSTORE 0x400000d0u")] + public const uint KKpMemstore = 0x400000d0U; + + [NativeTypeName("#define SDLK_KP_MEMRECALL 0x400000d1u")] + public const uint KKpMemrecall = 0x400000d1U; + + [NativeTypeName("#define SDLK_KP_MEMCLEAR 0x400000d2u")] + public const uint KKpMemclear = 0x400000d2U; + + [NativeTypeName("#define SDLK_KP_MEMADD 0x400000d3u")] + public const uint KKpMemadd = 0x400000d3U; + + [NativeTypeName("#define SDLK_KP_MEMSUBTRACT 0x400000d4u")] + public const uint KKpMemsubtract = 0x400000d4U; + + [NativeTypeName("#define SDLK_KP_MEMMULTIPLY 0x400000d5u")] + public const uint KKpMemmultiply = 0x400000d5U; + + [NativeTypeName("#define SDLK_KP_MEMDIVIDE 0x400000d6u")] + public const uint KKpMemdivide = 0x400000d6U; + + [NativeTypeName("#define SDLK_KP_PLUSMINUS 0x400000d7u")] + public const uint KKpPlusminus = 0x400000d7U; + + [NativeTypeName("#define SDLK_KP_CLEAR 0x400000d8u")] + public const uint KKpClear = 0x400000d8U; + + [NativeTypeName("#define SDLK_KP_CLEARENTRY 0x400000d9u")] + public const uint KKpClearentry = 0x400000d9U; + + [NativeTypeName("#define SDLK_KP_BINARY 0x400000dau")] + public const uint KKpBinary = 0x400000daU; + + [NativeTypeName("#define SDLK_KP_OCTAL 0x400000dbu")] + public const uint KKpOctal = 0x400000dbU; + + [NativeTypeName("#define SDLK_KP_DECIMAL 0x400000dcu")] + public const uint KKpDecimal = 0x400000dcU; + + [NativeTypeName("#define SDLK_KP_HEXADECIMAL 0x400000ddu")] + public const uint KKpHexadecimal = 0x400000ddU; + + [NativeTypeName("#define SDLK_LCTRL 0x400000e0u")] + public const uint KLctrl = 0x400000e0U; + + [NativeTypeName("#define SDLK_LSHIFT 0x400000e1u")] + public const uint KLshift = 0x400000e1U; + + [NativeTypeName("#define SDLK_LALT 0x400000e2u")] + public const uint KLalt = 0x400000e2U; + + [NativeTypeName("#define SDLK_LGUI 0x400000e3u")] + public const uint KLgui = 0x400000e3U; + + [NativeTypeName("#define SDLK_RCTRL 0x400000e4u")] + public const uint KRctrl = 0x400000e4U; + + [NativeTypeName("#define SDLK_RSHIFT 0x400000e5u")] + public const uint KRshift = 0x400000e5U; + + [NativeTypeName("#define SDLK_RALT 0x400000e6u")] + public const uint KRalt = 0x400000e6U; + + [NativeTypeName("#define SDLK_RGUI 0x400000e7u")] + public const uint KRgui = 0x400000e7U; + + [NativeTypeName("#define SDLK_MODE 0x40000101u")] + public const uint KMode = 0x40000101U; + + [NativeTypeName("#define SDLK_SLEEP 0x40000102u")] + public const uint KSleep = 0x40000102U; + + [NativeTypeName("#define SDLK_WAKE 0x40000103u")] + public const uint KWake = 0x40000103U; + + [NativeTypeName("#define SDLK_CHANNEL_INCREMENT 0x40000104u")] + public const uint KChannelIncrement = 0x40000104U; + + [NativeTypeName("#define SDLK_CHANNEL_DECREMENT 0x40000105u")] + public const uint KChannelDecrement = 0x40000105U; + + [NativeTypeName("#define SDLK_MEDIA_PLAY 0x40000106u")] + public const uint KMediaPlay = 0x40000106U; + + [NativeTypeName("#define SDLK_MEDIA_PAUSE 0x40000107u")] + public const uint KMediaPause = 0x40000107U; + + [NativeTypeName("#define SDLK_MEDIA_RECORD 0x40000108u")] + public const uint KMediaRecord = 0x40000108U; + + [NativeTypeName("#define SDLK_MEDIA_FAST_FORWARD 0x40000109u")] + public const uint KMediaFastForward = 0x40000109U; + + [NativeTypeName("#define SDLK_MEDIA_REWIND 0x4000010au")] + public const uint KMediaRewind = 0x4000010aU; + + [NativeTypeName("#define SDLK_MEDIA_NEXT_TRACK 0x4000010bu")] + public const uint KMediaNextTrack = 0x4000010bU; + + [NativeTypeName("#define SDLK_MEDIA_PREVIOUS_TRACK 0x4000010cu")] + public const uint KMediaPreviousTrack = 0x4000010cU; + + [NativeTypeName("#define SDLK_MEDIA_STOP 0x4000010du")] + public const uint KMediaStop = 0x4000010dU; + + [NativeTypeName("#define SDLK_MEDIA_EJECT 0x4000010eu")] + public const uint KMediaEject = 0x4000010eU; + + [NativeTypeName("#define SDLK_MEDIA_PLAY_PAUSE 0x4000010fu")] + public const uint KMediaPlayPause = 0x4000010fU; + + [NativeTypeName("#define SDLK_MEDIA_SELECT 0x40000110u")] + public const uint KMediaSelect = 0x40000110U; + + [NativeTypeName("#define SDLK_AC_NEW 0x40000111u")] + public const uint KAcNew = 0x40000111U; + + [NativeTypeName("#define SDLK_AC_OPEN 0x40000112u")] + public const uint KAcOpen = 0x40000112U; + + [NativeTypeName("#define SDLK_AC_CLOSE 0x40000113u")] + public const uint KAcClose = 0x40000113U; + + [NativeTypeName("#define SDLK_AC_EXIT 0x40000114u")] + public const uint KAcExit = 0x40000114U; + + [NativeTypeName("#define SDLK_AC_SAVE 0x40000115u")] + public const uint KAcSave = 0x40000115U; + + [NativeTypeName("#define SDLK_AC_PRINT 0x40000116u")] + public const uint KAcPrint = 0x40000116U; + + [NativeTypeName("#define SDLK_AC_PROPERTIES 0x40000117u")] + public const uint KAcProperties = 0x40000117U; + + [NativeTypeName("#define SDLK_AC_SEARCH 0x40000118u")] + public const uint KAcSearch = 0x40000118U; + + [NativeTypeName("#define SDLK_AC_HOME 0x40000119u")] + public const uint KAcHome = 0x40000119U; + + [NativeTypeName("#define SDLK_AC_BACK 0x4000011au")] + public const uint KAcBack = 0x4000011aU; + + [NativeTypeName("#define SDLK_AC_FORWARD 0x4000011bu")] + public const uint KAcForward = 0x4000011bU; + + [NativeTypeName("#define SDLK_AC_STOP 0x4000011cu")] + public const uint KAcStop = 0x4000011cU; + + [NativeTypeName("#define SDLK_AC_REFRESH 0x4000011du")] + public const uint KAcRefresh = 0x4000011dU; + + [NativeTypeName("#define SDLK_AC_BOOKMARKS 0x4000011eu")] + public const uint KAcBookmarks = 0x4000011eU; + + [NativeTypeName("#define SDLK_SOFTLEFT 0x4000011fu")] + public const uint KSoftleft = 0x4000011fU; + + [NativeTypeName("#define SDLK_SOFTRIGHT 0x40000120u")] + public const uint KSoftright = 0x40000120U; + + [NativeTypeName("#define SDLK_CALL 0x40000121u")] + public const uint KCall = 0x40000121U; + + [NativeTypeName("#define SDLK_ENDCALL 0x40000122u")] + public const uint KEndcall = 0x40000122U; + + [NativeTypeName("#define SDL_KMOD_NONE 0x0000u")] + public const uint KmodNone = 0x0000U; + + [NativeTypeName("#define SDL_KMOD_LSHIFT 0x0001u")] + public const uint KmodLshift = 0x0001U; + + [NativeTypeName("#define SDL_KMOD_RSHIFT 0x0002u")] + public const uint KmodRshift = 0x0002U; + + [NativeTypeName("#define SDL_KMOD_LCTRL 0x0040u")] + public const uint KmodLctrl = 0x0040U; + + [NativeTypeName("#define SDL_KMOD_RCTRL 0x0080u")] + public const uint KmodRctrl = 0x0080U; + + [NativeTypeName("#define SDL_KMOD_LALT 0x0100u")] + public const uint KmodLalt = 0x0100U; + + [NativeTypeName("#define SDL_KMOD_RALT 0x0200u")] + public const uint KmodRalt = 0x0200U; + + [NativeTypeName("#define SDL_KMOD_LGUI 0x0400u")] + public const uint KmodLgui = 0x0400U; + + [NativeTypeName("#define SDL_KMOD_RGUI 0x0800u")] + public const uint KmodRgui = 0x0800U; + + [NativeTypeName("#define SDL_KMOD_NUM 0x1000u")] + public const uint KmodNum = 0x1000U; + + [NativeTypeName("#define SDL_KMOD_CAPS 0x2000u")] + public const uint KmodCaps = 0x2000U; + + [NativeTypeName("#define SDL_KMOD_MODE 0x4000u")] + public const uint KmodMode = 0x4000U; + + [NativeTypeName("#define SDL_KMOD_SCROLL 0x8000u")] + public const uint KmodScroll = 0x8000U; + + [NativeTypeName("#define SDL_KMOD_CTRL (SDL_KMOD_LCTRL | SDL_KMOD_RCTRL)")] + public const uint KmodCtrl = (0x0040U | 0x0080U); + + [NativeTypeName("#define SDL_KMOD_SHIFT (SDL_KMOD_LSHIFT | SDL_KMOD_RSHIFT)")] + public const uint KmodShift = (0x0001U | 0x0002U); + + [NativeTypeName("#define SDL_KMOD_ALT (SDL_KMOD_LALT | SDL_KMOD_RALT)")] + public const uint KmodAlt = (0x0100U | 0x0200U); + + [NativeTypeName("#define SDL_KMOD_GUI (SDL_KMOD_LGUI | SDL_KMOD_RGUI)")] + public const uint KmodGui = (0x0400U | 0x0800U); + + [NativeTypeName("#define SDL_PROP_TEXTINPUT_TYPE_NUMBER \"SDL.textinput.type\"")] + public static Utf8String PropTextinputTypeNumber => "SDL.textinput.type"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTINPUT_CAPITALIZATION_NUMBER \"SDL.textinput.capitalization\"" + )] + public static Utf8String PropTextinputCapitalizationNumber => "SDL.textinput.capitalization"u8; + + [NativeTypeName("#define SDL_PROP_TEXTINPUT_AUTOCORRECT_BOOLEAN \"SDL.textinput.autocorrect\"")] + public static Utf8String PropTextinputAutocorrectBoolean => "SDL.textinput.autocorrect"u8; + + [NativeTypeName("#define SDL_PROP_TEXTINPUT_MULTILINE_BOOLEAN \"SDL.textinput.multiline\"")] + public static Utf8String PropTextinputMultilineBoolean => "SDL.textinput.multiline"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTINPUT_ANDROID_INPUTTYPE_NUMBER \"SDL.textinput.android.inputtype\"" + )] + public static Utf8String PropTextinputAndroidInputtypeNumber => + "SDL.textinput.android.inputtype"u8; + + [NativeTypeName("#define SDL_BUTTON_LEFT 1")] + public const int ButtonLeft = 1; + + [NativeTypeName("#define SDL_BUTTON_MIDDLE 2")] + public const int ButtonMiddle = 2; + + [NativeTypeName("#define SDL_BUTTON_RIGHT 3")] + public const int ButtonRight = 3; + + [NativeTypeName("#define SDL_BUTTON_X1 4")] + public const int ButtonX1 = 4; + + [NativeTypeName("#define SDL_BUTTON_X2 5")] + public const int ButtonX2 = 5; + + [NativeTypeName("#define SDL_BUTTON_LMASK SDL_BUTTON_MASK(SDL_BUTTON_LEFT)")] + public const uint ButtonLmask = (1U << ((1) - 1)); + + [NativeTypeName("#define SDL_BUTTON_MMASK SDL_BUTTON_MASK(SDL_BUTTON_MIDDLE)")] + public const uint ButtonMmask = (1U << ((2) - 1)); + + [NativeTypeName("#define SDL_BUTTON_RMASK SDL_BUTTON_MASK(SDL_BUTTON_RIGHT)")] + public const uint ButtonRmask = (1U << ((3) - 1)); + + [NativeTypeName("#define SDL_BUTTON_X1MASK SDL_BUTTON_MASK(SDL_BUTTON_X1)")] + public const uint ButtonX1Mask = (1U << ((4) - 1)); + + [NativeTypeName("#define SDL_BUTTON_X2MASK SDL_BUTTON_MASK(SDL_BUTTON_X2)")] + public const uint ButtonX2Mask = (1U << ((5) - 1)); + + [NativeTypeName("#define SDL_PEN_INPUT_DOWN (1u << 0)")] + public const uint PenInputDown = (1U << 0); + + [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_1 (1u << 1)")] + public const uint PenInputButton1 = (1U << 1); + + [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_2 (1u << 2)")] + public const uint PenInputButton2 = (1U << 2); + + [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_3 (1u << 3)")] + public const uint PenInputButton3 = (1U << 3); + + [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_4 (1u << 4)")] + public const uint PenInputButton4 = (1U << 4); + + [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_5 (1u << 5)")] + public const uint PenInputButton5 = (1U << 5); + + [NativeTypeName("#define SDL_PEN_INPUT_ERASER_TIP (1u << 30)")] + public const uint PenInputEraserTip = (1U << 30); + + [NativeTypeName("#define SDL_TOUCH_MOUSEID ((SDL_MouseID)-1)")] + public const uint TouchMouseid = unchecked((uint)(-1)); + + [NativeTypeName("#define SDL_MOUSE_TOUCHID ((SDL_TouchID)-1)")] + public const ulong MouseTouchid = unchecked((ulong)(-1)); + + [NativeTypeName("#define SDL_GLOB_CASEINSENSITIVE (1u << 0)")] + public const uint GlobCaseinsensitive = (1U << 0); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_SAMPLER (1u << 0)")] + public const uint GpuTextureusageSampler = (1U << 0); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_COLOR_TARGET (1u << 1)")] + public const uint GpuTextureusageColorTarget = (1U << 1); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET (1u << 2)")] + public const uint GpuTextureusageDepthStencilTarget = (1U << 2); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ (1u << 3)")] + public const uint GpuTextureusageGraphicsStorageRead = (1U << 3); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ (1u << 4)")] + public const uint GpuTextureusageComputeStorageRead = (1U << 4); + + [NativeTypeName("#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE (1u << 5)")] + public const uint GpuTextureusageComputeStorageWrite = (1U << 5); + + [NativeTypeName( + "#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE (1u << 6)" + )] + public const uint GpuTextureusageComputeStorageSimultaneousReadWrite = (1U << 6); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_VERTEX (1u << 0)")] + public const uint GpuBufferusageVertex = (1U << 0); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_INDEX (1u << 1)")] + public const uint GpuBufferusageIndex = (1U << 1); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_INDIRECT (1u << 2)")] + public const uint GpuBufferusageIndirect = (1U << 2); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ (1u << 3)")] + public const uint GpuBufferusageGraphicsStorageRead = (1U << 3); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ (1u << 4)")] + public const uint GpuBufferusageComputeStorageRead = (1U << 4); + + [NativeTypeName("#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE (1u << 5)")] + public const uint GpuBufferusageComputeStorageWrite = (1U << 5); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_INVALID 0")] + public const int GpuShaderformatInvalid = 0; + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_PRIVATE (1u << 0)")] + public const uint GpuShaderformatPrivate = (1U << 0); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_SPIRV (1u << 1)")] + public const uint GpuShaderformatSpirv = (1U << 1); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_DXBC (1u << 2)")] + public const uint GpuShaderformatDxbc = (1U << 2); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_DXIL (1u << 3)")] + public const uint GpuShaderformatDxil = (1U << 3); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_MSL (1u << 4)")] + public const uint GpuShaderformatMsl = (1U << 4); + + [NativeTypeName("#define SDL_GPU_SHADERFORMAT_METALLIB (1u << 5)")] + public const uint GpuShaderformatMetallib = (1U << 5); + + [NativeTypeName("#define SDL_GPU_COLORCOMPONENT_R (1u << 0)")] + public const uint GpuColorcomponentR = (1U << 0); + + [NativeTypeName("#define SDL_GPU_COLORCOMPONENT_G (1u << 1)")] + public const uint GpuColorcomponentG = (1U << 1); + + [NativeTypeName("#define SDL_GPU_COLORCOMPONENT_B (1u << 2)")] + public const uint GpuColorcomponentB = (1U << 2); + + [NativeTypeName("#define SDL_GPU_COLORCOMPONENT_A (1u << 3)")] + public const uint GpuColorcomponentA = (1U << 3); + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_R_FLOAT \"SDL.gpu.createtexture.d3d12.clear.r\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearRFloat => + "SDL.gpu.createtexture.d3d12.clear.r"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_G_FLOAT \"SDL.gpu.createtexture.d3d12.clear.g\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearGFloat => + "SDL.gpu.createtexture.d3d12.clear.g"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_B_FLOAT \"SDL.gpu.createtexture.d3d12.clear.b\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearBFloat => + "SDL.gpu.createtexture.d3d12.clear.b"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_A_FLOAT \"SDL.gpu.createtexture.d3d12.clear.a\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearAFloat => + "SDL.gpu.createtexture.d3d12.clear.a"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_DEPTH_FLOAT \"SDL.gpu.createtexture.d3d12.clear.depth\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearDepthFloat => + "SDL.gpu.createtexture.d3d12.clear.depth"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_STENCIL_UINT8 \"SDL.gpu.createtexture.d3d12.clear.stencil\"" + )] + public static Utf8String PropGpuCreatetextureD3D12ClearStencilUint8 => + "SDL.gpu.createtexture.d3d12.clear.stencil"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN \"SDL.gpu.device.create.debugmode\"" + )] + public static Utf8String PropGpuDeviceCreateDebugmodeBoolean => + "SDL.gpu.device.create.debugmode"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN \"SDL.gpu.device.create.preferlowpower\"" + )] + public static Utf8String PropGpuDeviceCreatePreferlowpowerBoolean => + "SDL.gpu.device.create.preferlowpower"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING \"SDL.gpu.device.create.name\"" + )] + public static Utf8String PropGpuDeviceCreateNameString => "SDL.gpu.device.create.name"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN \"SDL.gpu.device.create.shaders.private\"" + )] + public static Utf8String PropGpuDeviceCreateShadersPrivateBoolean => + "SDL.gpu.device.create.shaders.private"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN \"SDL.gpu.device.create.shaders.spirv\"" + )] + public static Utf8String PropGpuDeviceCreateShadersSpirvBoolean => + "SDL.gpu.device.create.shaders.spirv"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN \"SDL.gpu.device.create.shaders.dxbc\"" + )] + public static Utf8String PropGpuDeviceCreateShadersDxbcBoolean => + "SDL.gpu.device.create.shaders.dxbc"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN \"SDL.gpu.device.create.shaders.dxil\"" + )] + public static Utf8String PropGpuDeviceCreateShadersDxilBoolean => + "SDL.gpu.device.create.shaders.dxil"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN \"SDL.gpu.device.create.shaders.msl\"" + )] + public static Utf8String PropGpuDeviceCreateShadersMslBoolean => + "SDL.gpu.device.create.shaders.msl"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN \"SDL.gpu.device.create.shaders.metallib\"" + )] + public static Utf8String PropGpuDeviceCreateShadersMetallibBoolean => + "SDL.gpu.device.create.shaders.metallib"u8; + + [NativeTypeName( + "#define SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING \"SDL.gpu.device.create.d3d12.semantic\"" + )] + public static Utf8String PropGpuDeviceCreateD3D12SemanticNameString => + "SDL.gpu.device.create.d3d12.semantic"u8; + + [NativeTypeName("#define SDL_HAPTIC_CONSTANT (1u<<0)")] + public const uint HapticConstant = (1U << 0); + + [NativeTypeName("#define SDL_HAPTIC_SINE (1u<<1)")] + public const uint HapticSine = (1U << 1); + + [NativeTypeName("#define SDL_HAPTIC_SQUARE (1u<<2)")] + public const uint HapticSquare = (1U << 2); + + [NativeTypeName("#define SDL_HAPTIC_TRIANGLE (1u<<3)")] + public const uint HapticTriangle = (1U << 3); + + [NativeTypeName("#define SDL_HAPTIC_SAWTOOTHUP (1u<<4)")] + public const uint HapticSawtoothup = (1U << 4); + + [NativeTypeName("#define SDL_HAPTIC_SAWTOOTHDOWN (1u<<5)")] + public const uint HapticSawtoothdown = (1U << 5); + + [NativeTypeName("#define SDL_HAPTIC_RAMP (1u<<6)")] + public const uint HapticRamp = (1U << 6); + + [NativeTypeName("#define SDL_HAPTIC_SPRING (1u<<7)")] + public const uint HapticSpring = (1U << 7); + + [NativeTypeName("#define SDL_HAPTIC_DAMPER (1u<<8)")] + public const uint HapticDamper = (1U << 8); + + [NativeTypeName("#define SDL_HAPTIC_INERTIA (1u<<9)")] + public const uint HapticInertia = (1U << 9); + + [NativeTypeName("#define SDL_HAPTIC_FRICTION (1u<<10)")] + public const uint HapticFriction = (1U << 10); + + [NativeTypeName("#define SDL_HAPTIC_LEFTRIGHT (1u<<11)")] + public const uint HapticLeftright = (1U << 11); + + [NativeTypeName("#define SDL_HAPTIC_RESERVED1 (1u<<12)")] + public const uint HapticReserved1 = (1U << 12); + + [NativeTypeName("#define SDL_HAPTIC_RESERVED2 (1u<<13)")] + public const uint HapticReserved2 = (1U << 13); + + [NativeTypeName("#define SDL_HAPTIC_RESERVED3 (1u<<14)")] + public const uint HapticReserved3 = (1U << 14); + + [NativeTypeName("#define SDL_HAPTIC_CUSTOM (1u<<15)")] + public const uint HapticCustom = (1U << 15); + + [NativeTypeName("#define SDL_HAPTIC_GAIN (1u<<16)")] + public const uint HapticGain = (1U << 16); + + [NativeTypeName("#define SDL_HAPTIC_AUTOCENTER (1u<<17)")] + public const uint HapticAutocenter = (1U << 17); + + [NativeTypeName("#define SDL_HAPTIC_STATUS (1u<<18)")] + public const uint HapticStatus = (1U << 18); + + [NativeTypeName("#define SDL_HAPTIC_PAUSE (1u<<19)")] + public const uint HapticPause = (1U << 19); + + [NativeTypeName("#define SDL_HAPTIC_POLAR 0")] + public const int HapticPolar = 0; + + [NativeTypeName("#define SDL_HAPTIC_CARTESIAN 1")] + public const int HapticCartesian = 1; + + [NativeTypeName("#define SDL_HAPTIC_SPHERICAL 2")] + public const int HapticSpherical = 2; + + [NativeTypeName("#define SDL_HAPTIC_STEERING_AXIS 3")] + public const int HapticSteeringAxis = 3; + + [NativeTypeName("#define SDL_HAPTIC_INFINITY 4294967295U")] + public const uint HapticInfinity = 4294967295U; + + [NativeTypeName( + "#define SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED \"SDL_ALLOW_ALT_TAB_WHILE_GRABBED\"" + )] + public static Utf8String HintAllowAltTabWhileGrabbed => "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"u8; + + [NativeTypeName( + "#define SDL_HINT_ANDROID_ALLOW_RECREATE_ACTIVITY \"SDL_ANDROID_ALLOW_RECREATE_ACTIVITY\"" + )] + public static Utf8String HintAndroidAllowRecreateActivity => + "SDL_ANDROID_ALLOW_RECREATE_ACTIVITY"u8; + + [NativeTypeName("#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE \"SDL_ANDROID_BLOCK_ON_PAUSE\"")] + public static Utf8String HintAndroidBlockOnPause => "SDL_ANDROID_BLOCK_ON_PAUSE"u8; + + [NativeTypeName("#define SDL_HINT_ANDROID_TRAP_BACK_BUTTON \"SDL_ANDROID_TRAP_BACK_BUTTON\"")] + public static Utf8String HintAndroidTrapBackButton => "SDL_ANDROID_TRAP_BACK_BUTTON"u8; + + [NativeTypeName("#define SDL_HINT_APP_ID \"SDL_APP_ID\"")] + public static Utf8String HintAppId => "SDL_APP_ID"u8; + + [NativeTypeName("#define SDL_HINT_APP_NAME \"SDL_APP_NAME\"")] + public static Utf8String HintAppName => "SDL_APP_NAME"u8; + + [NativeTypeName( + "#define SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS \"SDL_APPLE_TV_CONTROLLER_UI_EVENTS\"" + )] + public static Utf8String HintAppleTvControllerUiEvents => "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"u8; + + [NativeTypeName( + "#define SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION \"SDL_APPLE_TV_REMOTE_ALLOW_ROTATION\"" + )] + public static Utf8String HintAppleTvRemoteAllowRotation => + "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_ALSA_DEFAULT_DEVICE \"SDL_AUDIO_ALSA_DEFAULT_DEVICE\"")] + public static Utf8String HintAudioAlsaDefaultDevice => "SDL_AUDIO_ALSA_DEFAULT_DEVICE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_CATEGORY \"SDL_AUDIO_CATEGORY\"")] + public static Utf8String HintAudioCategory => "SDL_AUDIO_CATEGORY"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_CHANNELS \"SDL_AUDIO_CHANNELS\"")] + public static Utf8String HintAudioChannels => "SDL_AUDIO_CHANNELS"u8; + + [NativeTypeName( + "#define SDL_HINT_AUDIO_DEVICE_APP_ICON_NAME \"SDL_AUDIO_DEVICE_APP_ICON_NAME\"" + )] + public static Utf8String HintAudioDeviceAppIconName => "SDL_AUDIO_DEVICE_APP_ICON_NAME"u8; + + [NativeTypeName( + "#define SDL_HINT_AUDIO_DEVICE_SAMPLE_FRAMES \"SDL_AUDIO_DEVICE_SAMPLE_FRAMES\"" + )] + public static Utf8String HintAudioDeviceSampleFrames => "SDL_AUDIO_DEVICE_SAMPLE_FRAMES"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DEVICE_STREAM_NAME \"SDL_AUDIO_DEVICE_STREAM_NAME\"")] + public static Utf8String HintAudioDeviceStreamName => "SDL_AUDIO_DEVICE_STREAM_NAME"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DEVICE_STREAM_ROLE \"SDL_AUDIO_DEVICE_STREAM_ROLE\"")] + public static Utf8String HintAudioDeviceStreamRole => "SDL_AUDIO_DEVICE_STREAM_ROLE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DISK_INPUT_FILE \"SDL_AUDIO_DISK_INPUT_FILE\"")] + public static Utf8String HintAudioDiskInputFile => "SDL_AUDIO_DISK_INPUT_FILE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DISK_OUTPUT_FILE \"SDL_AUDIO_DISK_OUTPUT_FILE\"")] + public static Utf8String HintAudioDiskOutputFile => "SDL_AUDIO_DISK_OUTPUT_FILE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DISK_TIMESCALE \"SDL_AUDIO_DISK_TIMESCALE\"")] + public static Utf8String HintAudioDiskTimescale => "SDL_AUDIO_DISK_TIMESCALE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DRIVER \"SDL_AUDIO_DRIVER\"")] + public static Utf8String HintAudioDriver => "SDL_AUDIO_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_DUMMY_TIMESCALE \"SDL_AUDIO_DUMMY_TIMESCALE\"")] + public static Utf8String HintAudioDummyTimescale => "SDL_AUDIO_DUMMY_TIMESCALE"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_FORMAT \"SDL_AUDIO_FORMAT\"")] + public static Utf8String HintAudioFormat => "SDL_AUDIO_FORMAT"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_FREQUENCY \"SDL_AUDIO_FREQUENCY\"")] + public static Utf8String HintAudioFrequency => "SDL_AUDIO_FREQUENCY"u8; + + [NativeTypeName("#define SDL_HINT_AUDIO_INCLUDE_MONITORS \"SDL_AUDIO_INCLUDE_MONITORS\"")] + public static Utf8String HintAudioIncludeMonitors => "SDL_AUDIO_INCLUDE_MONITORS"u8; + + [NativeTypeName("#define SDL_HINT_AUTO_UPDATE_JOYSTICKS \"SDL_AUTO_UPDATE_JOYSTICKS\"")] + public static Utf8String HintAutoUpdateJoysticks => "SDL_AUTO_UPDATE_JOYSTICKS"u8; + + [NativeTypeName("#define SDL_HINT_AUTO_UPDATE_SENSORS \"SDL_AUTO_UPDATE_SENSORS\"")] + public static Utf8String HintAutoUpdateSensors => "SDL_AUTO_UPDATE_SENSORS"u8; + + [NativeTypeName("#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT \"SDL_BMP_SAVE_LEGACY_FORMAT\"")] + public static Utf8String HintBmpSaveLegacyFormat => "SDL_BMP_SAVE_LEGACY_FORMAT"u8; + + [NativeTypeName("#define SDL_HINT_CAMERA_DRIVER \"SDL_CAMERA_DRIVER\"")] + public static Utf8String HintCameraDriver => "SDL_CAMERA_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_CPU_FEATURE_MASK \"SDL_CPU_FEATURE_MASK\"")] + public static Utf8String HintCpuFeatureMask => "SDL_CPU_FEATURE_MASK"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_DIRECTINPUT \"SDL_JOYSTICK_DIRECTINPUT\"")] + public static Utf8String HintJoystickDirectinput => "SDL_JOYSTICK_DIRECTINPUT"u8; + + [NativeTypeName("#define SDL_HINT_FILE_DIALOG_DRIVER \"SDL_FILE_DIALOG_DRIVER\"")] + public static Utf8String HintFileDialogDriver => "SDL_FILE_DIALOG_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_DISPLAY_USABLE_BOUNDS \"SDL_DISPLAY_USABLE_BOUNDS\"")] + public static Utf8String HintDisplayUsableBounds => "SDL_DISPLAY_USABLE_BOUNDS"u8; + + [NativeTypeName("#define SDL_HINT_EMSCRIPTEN_ASYNCIFY \"SDL_EMSCRIPTEN_ASYNCIFY\"")] + public static Utf8String HintEmscriptenAsyncify => "SDL_EMSCRIPTEN_ASYNCIFY"u8; + + [NativeTypeName( + "#define SDL_HINT_EMSCRIPTEN_CANVAS_SELECTOR \"SDL_EMSCRIPTEN_CANVAS_SELECTOR\"" + )] + public static Utf8String HintEmscriptenCanvasSelector => "SDL_EMSCRIPTEN_CANVAS_SELECTOR"u8; + + [NativeTypeName( + "#define SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT \"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\"" + )] + public static Utf8String HintEmscriptenKeyboardElement => "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"u8; + + [NativeTypeName("#define SDL_HINT_ENABLE_SCREEN_KEYBOARD \"SDL_ENABLE_SCREEN_KEYBOARD\"")] + public static Utf8String HintEnableScreenKeyboard => "SDL_ENABLE_SCREEN_KEYBOARD"u8; + + [NativeTypeName("#define SDL_HINT_EVDEV_DEVICES \"SDL_EVDEV_DEVICES\"")] + public static Utf8String HintEvdevDevices => "SDL_EVDEV_DEVICES"u8; + + [NativeTypeName("#define SDL_HINT_EVENT_LOGGING \"SDL_EVENT_LOGGING\"")] + public static Utf8String HintEventLogging => "SDL_EVENT_LOGGING"u8; + + [NativeTypeName("#define SDL_HINT_FORCE_RAISEWINDOW \"SDL_FORCE_RAISEWINDOW\"")] + public static Utf8String HintForceRaisewindow => "SDL_FORCE_RAISEWINDOW"u8; + + [NativeTypeName("#define SDL_HINT_FRAMEBUFFER_ACCELERATION \"SDL_FRAMEBUFFER_ACCELERATION\"")] + public static Utf8String HintFramebufferAcceleration => "SDL_FRAMEBUFFER_ACCELERATION"u8; + + [NativeTypeName("#define SDL_HINT_GAMECONTROLLERCONFIG \"SDL_GAMECONTROLLERCONFIG\"")] + public static Utf8String HintGamecontrollerconfig => "SDL_GAMECONTROLLERCONFIG"u8; + + [NativeTypeName("#define SDL_HINT_GAMECONTROLLERCONFIG_FILE \"SDL_GAMECONTROLLERCONFIG_FILE\"")] + public static Utf8String HintGamecontrollerconfigFile => "SDL_GAMECONTROLLERCONFIG_FILE"u8; + + [NativeTypeName("#define SDL_HINT_GAMECONTROLLERTYPE \"SDL_GAMECONTROLLERTYPE\"")] + public static Utf8String HintGamecontrollertype => "SDL_GAMECONTROLLERTYPE"u8; + + [NativeTypeName( + "#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES \"SDL_GAMECONTROLLER_IGNORE_DEVICES\"" + )] + public static Utf8String HintGamecontrollerIgnoreDevices => + "SDL_GAMECONTROLLER_IGNORE_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT \"SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT\"" + )] + public static Utf8String HintGamecontrollerIgnoreDevicesExcept => + "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"u8; + + [NativeTypeName( + "#define SDL_HINT_GAMECONTROLLER_SENSOR_FUSION \"SDL_GAMECONTROLLER_SENSOR_FUSION\"" + )] + public static Utf8String HintGamecontrollerSensorFusion => "SDL_GAMECONTROLLER_SENSOR_FUSION"u8; + + [NativeTypeName( + "#define SDL_HINT_GDK_TEXTINPUT_DEFAULT_TEXT \"SDL_GDK_TEXTINPUT_DEFAULT_TEXT\"" + )] + public static Utf8String HintGdkTextinputDefaultText => "SDL_GDK_TEXTINPUT_DEFAULT_TEXT"u8; + + [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_DESCRIPTION \"SDL_GDK_TEXTINPUT_DESCRIPTION\"")] + public static Utf8String HintGdkTextinputDescription => "SDL_GDK_TEXTINPUT_DESCRIPTION"u8; + + [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_MAX_LENGTH \"SDL_GDK_TEXTINPUT_MAX_LENGTH\"")] + public static Utf8String HintGdkTextinputMaxLength => "SDL_GDK_TEXTINPUT_MAX_LENGTH"u8; + + [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_SCOPE \"SDL_GDK_TEXTINPUT_SCOPE\"")] + public static Utf8String HintGdkTextinputScope => "SDL_GDK_TEXTINPUT_SCOPE"u8; + + [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_TITLE \"SDL_GDK_TEXTINPUT_TITLE\"")] + public static Utf8String HintGdkTextinputTitle => "SDL_GDK_TEXTINPUT_TITLE"u8; + + [NativeTypeName("#define SDL_HINT_HIDAPI_LIBUSB \"SDL_HIDAPI_LIBUSB\"")] + public static Utf8String HintHidapiLibusb => "SDL_HIDAPI_LIBUSB"u8; + + [NativeTypeName("#define SDL_HINT_HIDAPI_LIBUSB_WHITELIST \"SDL_HIDAPI_LIBUSB_WHITELIST\"")] + public static Utf8String HintHidapiLibusbWhitelist => "SDL_HIDAPI_LIBUSB_WHITELIST"u8; + + [NativeTypeName("#define SDL_HINT_HIDAPI_UDEV \"SDL_HIDAPI_UDEV\"")] + public static Utf8String HintHidapiUdev => "SDL_HIDAPI_UDEV"u8; + + [NativeTypeName("#define SDL_HINT_GPU_DRIVER \"SDL_GPU_DRIVER\"")] + public static Utf8String HintGpuDriver => "SDL_GPU_DRIVER"u8; + + [NativeTypeName( + "#define SDL_HINT_HIDAPI_ENUMERATE_ONLY_CONTROLLERS \"SDL_HIDAPI_ENUMERATE_ONLY_CONTROLLERS\"" + )] + public static Utf8String HintHidapiEnumerateOnlyControllers => + "SDL_HIDAPI_ENUMERATE_ONLY_CONTROLLERS"u8; + + [NativeTypeName("#define SDL_HINT_HIDAPI_IGNORE_DEVICES \"SDL_HIDAPI_IGNORE_DEVICES\"")] + public static Utf8String HintHidapiIgnoreDevices => "SDL_HIDAPI_IGNORE_DEVICES"u8; + + [NativeTypeName("#define SDL_HINT_IME_IMPLEMENTED_UI \"SDL_IME_IMPLEMENTED_UI\"")] + public static Utf8String HintImeImplementedUi => "SDL_IME_IMPLEMENTED_UI"u8; + + [NativeTypeName("#define SDL_HINT_IOS_HIDE_HOME_INDICATOR \"SDL_IOS_HIDE_HOME_INDICATOR\"")] + public static Utf8String HintIosHideHomeIndicator => "SDL_IOS_HIDE_HOME_INDICATOR"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS \"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS\"" + )] + public static Utf8String HintJoystickAllowBackgroundEvents => + "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES \"SDL_JOYSTICK_ARCADESTICK_DEVICES\"" + )] + public static Utf8String HintJoystickArcadestickDevices => "SDL_JOYSTICK_ARCADESTICK_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED \"SDL_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickArcadestickDevicesExcluded => + "SDL_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES \"SDL_JOYSTICK_BLACKLIST_DEVICES\"" + )] + public static Utf8String HintJoystickBlacklistDevices => "SDL_JOYSTICK_BLACKLIST_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED \"SDL_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickBlacklistDevicesExcluded => + "SDL_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_DEVICE \"SDL_JOYSTICK_DEVICE\"")] + public static Utf8String HintJoystickDevice => "SDL_JOYSTICK_DEVICE"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES \"SDL_JOYSTICK_FLIGHTSTICK_DEVICES\"" + )] + public static Utf8String HintJoystickFlightstickDevices => "SDL_JOYSTICK_FLIGHTSTICK_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED \"SDL_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickFlightstickDevicesExcluded => + "SDL_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_GAMEINPUT \"SDL_JOYSTICK_GAMEINPUT\"")] + public static Utf8String HintJoystickGameinput => "SDL_JOYSTICK_GAMEINPUT"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES \"SDL_JOYSTICK_GAMECUBE_DEVICES\"")] + public static Utf8String HintJoystickGamecubeDevices => "SDL_JOYSTICK_GAMECUBE_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED \"SDL_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickGamecubeDevicesExcluded => + "SDL_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI \"SDL_JOYSTICK_HIDAPI\"")] + public static Utf8String HintJoystickHidapi => "SDL_JOYSTICK_HIDAPI"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS \"SDL_JOYSTICK_HIDAPI_COMBINE_JOY_CONS\"" + )] + public static Utf8String HintJoystickHidapiCombineJoyCons => + "SDL_JOYSTICK_HIDAPI_COMBINE_JOY_CONS"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE \"SDL_JOYSTICK_HIDAPI_GAMECUBE\"")] + public static Utf8String HintJoystickHidapiGamecube => "SDL_JOYSTICK_HIDAPI_GAMECUBE"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE \"SDL_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE\"" + )] + public static Utf8String HintJoystickHidapiGamecubeRumbleBrake => + "SDL_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS \"SDL_JOYSTICK_HIDAPI_JOY_CONS\"")] + public static Utf8String HintJoystickHidapiJoyCons => "SDL_JOYSTICK_HIDAPI_JOY_CONS"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED \"SDL_JOYSTICK_HIDAPI_JOYCON_HOME_LED\"" + )] + public static Utf8String HintJoystickHidapiJoyconHomeLed => + "SDL_JOYSTICK_HIDAPI_JOYCON_HOME_LED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_LUNA \"SDL_JOYSTICK_HIDAPI_LUNA\"")] + public static Utf8String HintJoystickHidapiLuna => "SDL_JOYSTICK_HIDAPI_LUNA"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC \"SDL_JOYSTICK_HIDAPI_NINTENDO_CLASSIC\"" + )] + public static Utf8String HintJoystickHidapiNintendoClassic => + "SDL_JOYSTICK_HIDAPI_NINTENDO_CLASSIC"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS3 \"SDL_JOYSTICK_HIDAPI_PS3\"")] + public static Utf8String HintJoystickHidapiPs3 => "SDL_JOYSTICK_HIDAPI_PS3"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER \"SDL_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER\"" + )] + public static Utf8String HintJoystickHidapiPs3SixaxisDriver => + "SDL_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS4 \"SDL_JOYSTICK_HIDAPI_PS4\"")] + public static Utf8String HintJoystickHidapiPs4 => "SDL_JOYSTICK_HIDAPI_PS4"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL \"SDL_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL\"" + )] + public static Utf8String HintJoystickHidapiPs4ReportInterval => + "SDL_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE \"SDL_JOYSTICK_HIDAPI_PS4_RUMBLE\"" + )] + public static Utf8String HintJoystickHidapiPs4Rumble => "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS5 \"SDL_JOYSTICK_HIDAPI_PS5\"")] + public static Utf8String HintJoystickHidapiPs5 => "SDL_JOYSTICK_HIDAPI_PS5"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED\"" + )] + public static Utf8String HintJoystickHidapiPs5PlayerLed => + "SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE \"SDL_JOYSTICK_HIDAPI_PS5_RUMBLE\"" + )] + public static Utf8String HintJoystickHidapiPs5Rumble => "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_SHIELD \"SDL_JOYSTICK_HIDAPI_SHIELD\"")] + public static Utf8String HintJoystickHidapiShield => "SDL_JOYSTICK_HIDAPI_SHIELD"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STADIA \"SDL_JOYSTICK_HIDAPI_STADIA\"")] + public static Utf8String HintJoystickHidapiStadia => "SDL_JOYSTICK_HIDAPI_STADIA"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STEAM \"SDL_JOYSTICK_HIDAPI_STEAM\"")] + public static Utf8String HintJoystickHidapiSteam => "SDL_JOYSTICK_HIDAPI_STEAM"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK \"SDL_JOYSTICK_HIDAPI_STEAMDECK\"")] + public static Utf8String HintJoystickHidapiSteamdeck => "SDL_JOYSTICK_HIDAPI_STEAMDECK"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI \"SDL_JOYSTICK_HIDAPI_STEAM_HORI\"" + )] + public static Utf8String HintJoystickHidapiSteamHori => "SDL_JOYSTICK_HIDAPI_STEAM_HORI"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH \"SDL_JOYSTICK_HIDAPI_SWITCH\"")] + public static Utf8String HintJoystickHidapiSwitch => "SDL_JOYSTICK_HIDAPI_SWITCH"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED \"SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED\"" + )] + public static Utf8String HintJoystickHidapiSwitchHomeLed => + "SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED\"" + )] + public static Utf8String HintJoystickHidapiSwitchPlayerLed => + "SDL_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS \"SDL_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS\"" + )] + public static Utf8String HintJoystickHidapiVerticalJoyCons => + "SDL_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_WII \"SDL_JOYSTICK_HIDAPI_WII\"")] + public static Utf8String HintJoystickHidapiWii => "SDL_JOYSTICK_HIDAPI_WII"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_WII_PLAYER_LED\"" + )] + public static Utf8String HintJoystickHidapiWiiPlayerLed => + "SDL_JOYSTICK_HIDAPI_WII_PLAYER_LED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX \"SDL_JOYSTICK_HIDAPI_XBOX\"")] + public static Utf8String HintJoystickHidapiXbox => "SDL_JOYSTICK_HIDAPI_XBOX"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360 \"SDL_JOYSTICK_HIDAPI_XBOX_360\"")] + public static Utf8String HintJoystickHidapiXbox360 => "SDL_JOYSTICK_HIDAPI_XBOX_360"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED\"" + )] + public static Utf8String HintJoystickHidapiXbox360PlayerLed => + "SDL_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS \"SDL_JOYSTICK_HIDAPI_XBOX_360_WIRELESS\"" + )] + public static Utf8String HintJoystickHidapiXbox360Wireless => + "SDL_JOYSTICK_HIDAPI_XBOX_360_WIRELESS"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE \"SDL_JOYSTICK_HIDAPI_XBOX_ONE\"")] + public static Utf8String HintJoystickHidapiXboxOne => "SDL_JOYSTICK_HIDAPI_XBOX_ONE"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED \"SDL_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED\"" + )] + public static Utf8String HintJoystickHidapiXboxOneHomeLed => + "SDL_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_IOKIT \"SDL_JOYSTICK_IOKIT\"")] + public static Utf8String HintJoystickIokit => "SDL_JOYSTICK_IOKIT"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_LINUX_CLASSIC \"SDL_JOYSTICK_LINUX_CLASSIC\"")] + public static Utf8String HintJoystickLinuxClassic => "SDL_JOYSTICK_LINUX_CLASSIC"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_LINUX_DEADZONES \"SDL_JOYSTICK_LINUX_DEADZONES\"")] + public static Utf8String HintJoystickLinuxDeadzones => "SDL_JOYSTICK_LINUX_DEADZONES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_LINUX_DIGITAL_HATS \"SDL_JOYSTICK_LINUX_DIGITAL_HATS\"" + )] + public static Utf8String HintJoystickLinuxDigitalHats => "SDL_JOYSTICK_LINUX_DIGITAL_HATS"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_LINUX_HAT_DEADZONES \"SDL_JOYSTICK_LINUX_HAT_DEADZONES\"" + )] + public static Utf8String HintJoystickLinuxHatDeadzones => "SDL_JOYSTICK_LINUX_HAT_DEADZONES"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_MFI \"SDL_JOYSTICK_MFI\"")] + public static Utf8String HintJoystickMfi => "SDL_JOYSTICK_MFI"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_RAWINPUT \"SDL_JOYSTICK_RAWINPUT\"")] + public static Utf8String HintJoystickRawinput => "SDL_JOYSTICK_RAWINPUT"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT \"SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT\"" + )] + public static Utf8String HintJoystickRawinputCorrelateXinput => + "SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_ROG_CHAKRAM \"SDL_JOYSTICK_ROG_CHAKRAM\"")] + public static Utf8String HintJoystickRogChakram => "SDL_JOYSTICK_ROG_CHAKRAM"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_THREAD \"SDL_JOYSTICK_THREAD\"")] + public static Utf8String HintJoystickThread => "SDL_JOYSTICK_THREAD"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_THROTTLE_DEVICES \"SDL_JOYSTICK_THROTTLE_DEVICES\"")] + public static Utf8String HintJoystickThrottleDevices => "SDL_JOYSTICK_THROTTLE_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_THROTTLE_DEVICES_EXCLUDED \"SDL_JOYSTICK_THROTTLE_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickThrottleDevicesExcluded => + "SDL_JOYSTICK_THROTTLE_DEVICES_EXCLUDED"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_WGI \"SDL_JOYSTICK_WGI\"")] + public static Utf8String HintJoystickWgi => "SDL_JOYSTICK_WGI"u8; + + [NativeTypeName("#define SDL_HINT_JOYSTICK_WHEEL_DEVICES \"SDL_JOYSTICK_WHEEL_DEVICES\"")] + public static Utf8String HintJoystickWheelDevices => "SDL_JOYSTICK_WHEEL_DEVICES"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_WHEEL_DEVICES_EXCLUDED \"SDL_JOYSTICK_WHEEL_DEVICES_EXCLUDED\"" + )] + public static Utf8String HintJoystickWheelDevicesExcluded => + "SDL_JOYSTICK_WHEEL_DEVICES_EXCLUDED"u8; + + [NativeTypeName( + "#define SDL_HINT_JOYSTICK_ZERO_CENTERED_DEVICES \"SDL_JOYSTICK_ZERO_CENTERED_DEVICES\"" + )] + public static Utf8String HintJoystickZeroCenteredDevices => + "SDL_JOYSTICK_ZERO_CENTERED_DEVICES"u8; + + [NativeTypeName("#define SDL_HINT_KEYCODE_OPTIONS \"SDL_KEYCODE_OPTIONS\"")] + public static Utf8String HintKeycodeOptions => "SDL_KEYCODE_OPTIONS"u8; + + [NativeTypeName("#define SDL_HINT_KMSDRM_DEVICE_INDEX \"SDL_KMSDRM_DEVICE_INDEX\"")] + public static Utf8String HintKmsdrmDeviceIndex => "SDL_KMSDRM_DEVICE_INDEX"u8; + + [NativeTypeName("#define SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER \"SDL_KMSDRM_REQUIRE_DRM_MASTER\"")] + public static Utf8String HintKmsdrmRequireDrmMaster => "SDL_KMSDRM_REQUIRE_DRM_MASTER"u8; + + [NativeTypeName("#define SDL_HINT_LOGGING \"SDL_LOGGING\"")] + public static Utf8String HintLogging => "SDL_LOGGING"u8; + + [NativeTypeName("#define SDL_HINT_MAC_BACKGROUND_APP \"SDL_MAC_BACKGROUND_APP\"")] + public static Utf8String HintMacBackgroundApp => "SDL_MAC_BACKGROUND_APP"u8; + + [NativeTypeName( + "#define SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK \"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK\"" + )] + public static Utf8String HintMacCtrlClickEmulateRightClick => + "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"u8; + + [NativeTypeName("#define SDL_HINT_MAC_OPENGL_ASYNC_DISPATCH \"SDL_MAC_OPENGL_ASYNC_DISPATCH\"")] + public static Utf8String HintMacOpenglAsyncDispatch => "SDL_MAC_OPENGL_ASYNC_DISPATCH"u8; + + [NativeTypeName("#define SDL_HINT_MAC_SCROLL_MOMENTUM \"SDL_MAC_SCROLL_MOMENTUM\"")] + public static Utf8String HintMacScrollMomentum => "SDL_MAC_SCROLL_MOMENTUM"u8; + + [NativeTypeName("#define SDL_HINT_MAIN_CALLBACK_RATE \"SDL_MAIN_CALLBACK_RATE\"")] + public static Utf8String HintMainCallbackRate => "SDL_MAIN_CALLBACK_RATE"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_AUTO_CAPTURE \"SDL_MOUSE_AUTO_CAPTURE\"")] + public static Utf8String HintMouseAutoCapture => "SDL_MOUSE_AUTO_CAPTURE"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS \"SDL_MOUSE_DOUBLE_CLICK_RADIUS\"")] + public static Utf8String HintMouseDoubleClickRadius => "SDL_MOUSE_DOUBLE_CLICK_RADIUS"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME \"SDL_MOUSE_DOUBLE_CLICK_TIME\"")] + public static Utf8String HintMouseDoubleClickTime => "SDL_MOUSE_DOUBLE_CLICK_TIME"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_EMULATE_WARP_WITH_RELATIVE \"SDL_MOUSE_EMULATE_WARP_WITH_RELATIVE\"" + )] + public static Utf8String HintMouseEmulateWarpWithRelative => + "SDL_MOUSE_EMULATE_WARP_WITH_RELATIVE"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH \"SDL_MOUSE_FOCUS_CLICKTHROUGH\"")] + public static Utf8String HintMouseFocusClickthrough => "SDL_MOUSE_FOCUS_CLICKTHROUGH"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE \"SDL_MOUSE_NORMAL_SPEED_SCALE\"")] + public static Utf8String HintMouseNormalSpeedScale => "SDL_MOUSE_NORMAL_SPEED_SCALE"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_MODE_CENTER \"SDL_MOUSE_RELATIVE_MODE_CENTER\"" + )] + public static Utf8String HintMouseRelativeModeCenter => "SDL_MOUSE_RELATIVE_MODE_CENTER"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_RELATIVE_MODE_WARP \"SDL_MOUSE_RELATIVE_MODE_WARP\"")] + public static Utf8String HintMouseRelativeModeWarp => "SDL_MOUSE_RELATIVE_MODE_WARP"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE \"SDL_MOUSE_RELATIVE_SPEED_SCALE\"" + )] + public static Utf8String HintMouseRelativeSpeedScale => "SDL_MOUSE_RELATIVE_SPEED_SCALE"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE \"SDL_MOUSE_RELATIVE_SYSTEM_SCALE\"" + )] + public static Utf8String HintMouseRelativeSystemScale => "SDL_MOUSE_RELATIVE_SYSTEM_SCALE"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_WARP_MOTION \"SDL_MOUSE_RELATIVE_WARP_MOTION\"" + )] + public static Utf8String HintMouseRelativeWarpMotion => "SDL_MOUSE_RELATIVE_WARP_MOTION"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE \"SDL_MOUSE_RELATIVE_CURSOR_VISIBLE\"" + )] + public static Utf8String HintMouseRelativeCursorVisible => + "SDL_MOUSE_RELATIVE_CURSOR_VISIBLE"u8; + + [NativeTypeName( + "#define SDL_HINT_MOUSE_RELATIVE_CLIP_INTERVAL \"SDL_MOUSE_RELATIVE_CLIP_INTERVAL\"" + )] + public static Utf8String HintMouseRelativeClipInterval => "SDL_MOUSE_RELATIVE_CLIP_INTERVAL"u8; + + [NativeTypeName("#define SDL_HINT_MOUSE_TOUCH_EVENTS \"SDL_MOUSE_TOUCH_EVENTS\"")] + public static Utf8String HintMouseTouchEvents => "SDL_MOUSE_TOUCH_EVENTS"u8; + + [NativeTypeName("#define SDL_HINT_MUTE_CONSOLE_KEYBOARD \"SDL_MUTE_CONSOLE_KEYBOARD\"")] + public static Utf8String HintMuteConsoleKeyboard => "SDL_MUTE_CONSOLE_KEYBOARD"u8; + + [NativeTypeName("#define SDL_HINT_NO_SIGNAL_HANDLERS \"SDL_NO_SIGNAL_HANDLERS\"")] + public static Utf8String HintNoSignalHandlers => "SDL_NO_SIGNAL_HANDLERS"u8; + + [NativeTypeName("#define SDL_HINT_OPENGL_LIBRARY \"SDL_OPENGL_LIBRARY\"")] + public static Utf8String HintOpenglLibrary => "SDL_OPENGL_LIBRARY"u8; + + [NativeTypeName("#define SDL_HINT_OPENGL_ES_DRIVER \"SDL_OPENGL_ES_DRIVER\"")] + public static Utf8String HintOpenglEsDriver => "SDL_OPENGL_ES_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_OPENVR_LIBRARY \"SDL_OPENVR_LIBRARY\"")] + public static Utf8String HintOpenvrLibrary => "SDL_OPENVR_LIBRARY"u8; + + [NativeTypeName("#define SDL_HINT_ORIENTATIONS \"SDL_ORIENTATIONS\"")] + public static Utf8String HintOrientations => "SDL_ORIENTATIONS"u8; + + [NativeTypeName("#define SDL_HINT_POLL_SENTINEL \"SDL_POLL_SENTINEL\"")] + public static Utf8String HintPollSentinel => "SDL_POLL_SENTINEL"u8; + + [NativeTypeName("#define SDL_HINT_PREFERRED_LOCALES \"SDL_PREFERRED_LOCALES\"")] + public static Utf8String HintPreferredLocales => "SDL_PREFERRED_LOCALES"u8; + + [NativeTypeName("#define SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE \"SDL_QUIT_ON_LAST_WINDOW_CLOSE\"")] + public static Utf8String HintQuitOnLastWindowClose => "SDL_QUIT_ON_LAST_WINDOW_CLOSE"u8; + + [NativeTypeName( + "#define SDL_HINT_RENDER_DIRECT3D_THREADSAFE \"SDL_RENDER_DIRECT3D_THREADSAFE\"" + )] + public static Utf8String HintRenderDirect3DThreadsafe => "SDL_RENDER_DIRECT3D_THREADSAFE"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_DIRECT3D11_DEBUG \"SDL_RENDER_DIRECT3D11_DEBUG\"")] + public static Utf8String HintRenderDirect3D11Debug => "SDL_RENDER_DIRECT3D11_DEBUG"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_VULKAN_DEBUG \"SDL_RENDER_VULKAN_DEBUG\"")] + public static Utf8String HintRenderVulkanDebug => "SDL_RENDER_VULKAN_DEBUG"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_GPU_DEBUG \"SDL_RENDER_GPU_DEBUG\"")] + public static Utf8String HintRenderGpuDebug => "SDL_RENDER_GPU_DEBUG"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_GPU_LOW_POWER \"SDL_RENDER_GPU_LOW_POWER\"")] + public static Utf8String HintRenderGpuLowPower => "SDL_RENDER_GPU_LOW_POWER"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_DRIVER \"SDL_RENDER_DRIVER\"")] + public static Utf8String HintRenderDriver => "SDL_RENDER_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_LINE_METHOD \"SDL_RENDER_LINE_METHOD\"")] + public static Utf8String HintRenderLineMethod => "SDL_RENDER_LINE_METHOD"u8; + + [NativeTypeName( + "#define SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE \"SDL_RENDER_METAL_PREFER_LOW_POWER_DEVICE\"" + )] + public static Utf8String HintRenderMetalPreferLowPowerDevice => + "SDL_RENDER_METAL_PREFER_LOW_POWER_DEVICE"u8; + + [NativeTypeName("#define SDL_HINT_RENDER_VSYNC \"SDL_RENDER_VSYNC\"")] + public static Utf8String HintRenderVsync => "SDL_RENDER_VSYNC"u8; + + [NativeTypeName("#define SDL_HINT_RETURN_KEY_HIDES_IME \"SDL_RETURN_KEY_HIDES_IME\"")] + public static Utf8String HintReturnKeyHidesIme => "SDL_RETURN_KEY_HIDES_IME"u8; + + [NativeTypeName("#define SDL_HINT_ROG_GAMEPAD_MICE \"SDL_ROG_GAMEPAD_MICE\"")] + public static Utf8String HintRogGamepadMice => "SDL_ROG_GAMEPAD_MICE"u8; + + [NativeTypeName("#define SDL_HINT_ROG_GAMEPAD_MICE_EXCLUDED \"SDL_ROG_GAMEPAD_MICE_EXCLUDED\"")] + public static Utf8String HintRogGamepadMiceExcluded => "SDL_ROG_GAMEPAD_MICE_EXCLUDED"u8; + + [NativeTypeName("#define SDL_HINT_RPI_VIDEO_LAYER \"SDL_RPI_VIDEO_LAYER\"")] + public static Utf8String HintRpiVideoLayer => "SDL_RPI_VIDEO_LAYER"u8; + + [NativeTypeName( + "#define SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME \"SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME\"" + )] + public static Utf8String HintScreensaverInhibitActivityName => + "SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME"u8; + + [NativeTypeName("#define SDL_HINT_SHUTDOWN_DBUS_ON_QUIT \"SDL_SHUTDOWN_DBUS_ON_QUIT\"")] + public static Utf8String HintShutdownDbusOnQuit => "SDL_SHUTDOWN_DBUS_ON_QUIT"u8; + + [NativeTypeName("#define SDL_HINT_STORAGE_TITLE_DRIVER \"SDL_STORAGE_TITLE_DRIVER\"")] + public static Utf8String HintStorageTitleDriver => "SDL_STORAGE_TITLE_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_STORAGE_USER_DRIVER \"SDL_STORAGE_USER_DRIVER\"")] + public static Utf8String HintStorageUserDriver => "SDL_STORAGE_USER_DRIVER"u8; + + [NativeTypeName( + "#define SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL \"SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL\"" + )] + public static Utf8String HintThreadForceRealtimeTimeCritical => + "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL"u8; + + [NativeTypeName("#define SDL_HINT_THREAD_PRIORITY_POLICY \"SDL_THREAD_PRIORITY_POLICY\"")] + public static Utf8String HintThreadPriorityPolicy => "SDL_THREAD_PRIORITY_POLICY"u8; + + [NativeTypeName("#define SDL_HINT_TIMER_RESOLUTION \"SDL_TIMER_RESOLUTION\"")] + public static Utf8String HintTimerResolution => "SDL_TIMER_RESOLUTION"u8; + + [NativeTypeName("#define SDL_HINT_TOUCH_MOUSE_EVENTS \"SDL_TOUCH_MOUSE_EVENTS\"")] + public static Utf8String HintTouchMouseEvents => "SDL_TOUCH_MOUSE_EVENTS"u8; + + [NativeTypeName("#define SDL_HINT_TRACKPAD_IS_TOUCH_ONLY \"SDL_TRACKPAD_IS_TOUCH_ONLY\"")] + public static Utf8String HintTrackpadIsTouchOnly => "SDL_TRACKPAD_IS_TOUCH_ONLY"u8; + + [NativeTypeName("#define SDL_HINT_TV_REMOTE_AS_JOYSTICK \"SDL_TV_REMOTE_AS_JOYSTICK\"")] + public static Utf8String HintTvRemoteAsJoystick => "SDL_TV_REMOTE_AS_JOYSTICK"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_ALLOW_SCREENSAVER \"SDL_VIDEO_ALLOW_SCREENSAVER\"")] + public static Utf8String HintVideoAllowScreensaver => "SDL_VIDEO_ALLOW_SCREENSAVER"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_DISPLAY_PRIORITY \"SDL_VIDEO_DISPLAY_PRIORITY\"")] + public static Utf8String HintVideoDisplayPriority => "SDL_VIDEO_DISPLAY_PRIORITY"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_DOUBLE_BUFFER \"SDL_VIDEO_DOUBLE_BUFFER\"")] + public static Utf8String HintVideoDoubleBuffer => "SDL_VIDEO_DOUBLE_BUFFER"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_DRIVER \"SDL_VIDEO_DRIVER\"")] + public static Utf8String HintVideoDriver => "SDL_VIDEO_DRIVER"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_DUMMY_SAVE_FRAMES \"SDL_VIDEO_DUMMY_SAVE_FRAMES\"")] + public static Utf8String HintVideoDummySaveFrames => "SDL_VIDEO_DUMMY_SAVE_FRAMES"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK \"SDL_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK\"" + )] + public static Utf8String HintVideoEglAllowGetdisplayFallback => + "SDL_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_FORCE_EGL \"SDL_VIDEO_FORCE_EGL\"")] + public static Utf8String HintVideoForceEgl => "SDL_VIDEO_FORCE_EGL"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES \"SDL_VIDEO_MAC_FULLSCREEN_SPACES\"" + )] + public static Utf8String HintVideoMacFullscreenSpaces => "SDL_VIDEO_MAC_FULLSCREEN_SPACES"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS \"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\"" + )] + public static Utf8String HintVideoMinimizeOnFocusLoss => "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_OFFSCREEN_SAVE_FRAMES \"SDL_VIDEO_OFFSCREEN_SAVE_FRAMES\"" + )] + public static Utf8String HintVideoOffscreenSaveFrames => "SDL_VIDEO_OFFSCREEN_SAVE_FRAMES"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_SYNC_WINDOW_OPERATIONS \"SDL_VIDEO_SYNC_WINDOW_OPERATIONS\"" + )] + public static Utf8String HintVideoSyncWindowOperations => "SDL_VIDEO_SYNC_WINDOW_OPERATIONS"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR \"SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR\"" + )] + public static Utf8String HintVideoWaylandAllowLibdecor => "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_WAYLAND_MODE_EMULATION \"SDL_VIDEO_WAYLAND_MODE_EMULATION\"" + )] + public static Utf8String HintVideoWaylandModeEmulation => "SDL_VIDEO_WAYLAND_MODE_EMULATION"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_WAYLAND_MODE_SCALING \"SDL_VIDEO_WAYLAND_MODE_SCALING\"" + )] + public static Utf8String HintVideoWaylandModeScaling => "SDL_VIDEO_WAYLAND_MODE_SCALING"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR \"SDL_VIDEO_WAYLAND_PREFER_LIBDECOR\"" + )] + public static Utf8String HintVideoWaylandPreferLibdecor => + "SDL_VIDEO_WAYLAND_PREFER_LIBDECOR"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_WAYLAND_SCALE_TO_DISPLAY \"SDL_VIDEO_WAYLAND_SCALE_TO_DISPLAY\"" + )] + public static Utf8String HintVideoWaylandScaleToDisplay => + "SDL_VIDEO_WAYLAND_SCALE_TO_DISPLAY"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_WIN_D3DCOMPILER \"SDL_VIDEO_WIN_D3DCOMPILER\"")] + public static Utf8String HintVideoWinD3Dcompiler => "SDL_VIDEO_WIN_D3DCOMPILER"u8; + + [NativeTypeName( + "#define SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR \"SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR\"" + )] + public static Utf8String HintVideoX11NetWmBypassCompositor => + "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_NET_WM_PING \"SDL_VIDEO_X11_NET_WM_PING\"")] + public static Utf8String HintVideoX11NetWmPing => "SDL_VIDEO_X11_NET_WM_PING"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_NODIRECTCOLOR \"SDL_VIDEO_X11_NODIRECTCOLOR\"")] + public static Utf8String HintVideoX11Nodirectcolor => "SDL_VIDEO_X11_NODIRECTCOLOR"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_SCALING_FACTOR \"SDL_VIDEO_X11_SCALING_FACTOR\"")] + public static Utf8String HintVideoX11ScalingFactor => "SDL_VIDEO_X11_SCALING_FACTOR"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_VISUALID \"SDL_VIDEO_X11_VISUALID\"")] + public static Utf8String HintVideoX11Visualid => "SDL_VIDEO_X11_VISUALID"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_WINDOW_VISUALID \"SDL_VIDEO_X11_WINDOW_VISUALID\"")] + public static Utf8String HintVideoX11WindowVisualid => "SDL_VIDEO_X11_WINDOW_VISUALID"u8; + + [NativeTypeName("#define SDL_HINT_VIDEO_X11_XRANDR \"SDL_VIDEO_X11_XRANDR\"")] + public static Utf8String HintVideoX11Xrandr => "SDL_VIDEO_X11_XRANDR"u8; + + [NativeTypeName("#define SDL_HINT_VITA_ENABLE_BACK_TOUCH \"SDL_VITA_ENABLE_BACK_TOUCH\"")] + public static Utf8String HintVitaEnableBackTouch => "SDL_VITA_ENABLE_BACK_TOUCH"u8; + + [NativeTypeName("#define SDL_HINT_VITA_ENABLE_FRONT_TOUCH \"SDL_VITA_ENABLE_FRONT_TOUCH\"")] + public static Utf8String HintVitaEnableFrontTouch => "SDL_VITA_ENABLE_FRONT_TOUCH"u8; + + [NativeTypeName("#define SDL_HINT_VITA_MODULE_PATH \"SDL_VITA_MODULE_PATH\"")] + public static Utf8String HintVitaModulePath => "SDL_VITA_MODULE_PATH"u8; + + [NativeTypeName("#define SDL_HINT_VITA_PVR_INIT \"SDL_VITA_PVR_INIT\"")] + public static Utf8String HintVitaPvrInit => "SDL_VITA_PVR_INIT"u8; + + [NativeTypeName("#define SDL_HINT_VITA_RESOLUTION \"SDL_VITA_RESOLUTION\"")] + public static Utf8String HintVitaResolution => "SDL_VITA_RESOLUTION"u8; + + [NativeTypeName("#define SDL_HINT_VITA_PVR_OPENGL \"SDL_VITA_PVR_OPENGL\"")] + public static Utf8String HintVitaPvrOpengl => "SDL_VITA_PVR_OPENGL"u8; + + [NativeTypeName("#define SDL_HINT_VITA_TOUCH_MOUSE_DEVICE \"SDL_VITA_TOUCH_MOUSE_DEVICE\"")] + public static Utf8String HintVitaTouchMouseDevice => "SDL_VITA_TOUCH_MOUSE_DEVICE"u8; + + [NativeTypeName("#define SDL_HINT_VULKAN_DISPLAY \"SDL_VULKAN_DISPLAY\"")] + public static Utf8String HintVulkanDisplay => "SDL_VULKAN_DISPLAY"u8; + + [NativeTypeName("#define SDL_HINT_VULKAN_LIBRARY \"SDL_VULKAN_LIBRARY\"")] + public static Utf8String HintVulkanLibrary => "SDL_VULKAN_LIBRARY"u8; + + [NativeTypeName("#define SDL_HINT_WAVE_FACT_CHUNK \"SDL_WAVE_FACT_CHUNK\"")] + public static Utf8String HintWaveFactChunk => "SDL_WAVE_FACT_CHUNK"u8; + + [NativeTypeName("#define SDL_HINT_WAVE_CHUNK_LIMIT \"SDL_WAVE_CHUNK_LIMIT\"")] + public static Utf8String HintWaveChunkLimit => "SDL_WAVE_CHUNK_LIMIT"u8; + + [NativeTypeName("#define SDL_HINT_WAVE_RIFF_CHUNK_SIZE \"SDL_WAVE_RIFF_CHUNK_SIZE\"")] + public static Utf8String HintWaveRiffChunkSize => "SDL_WAVE_RIFF_CHUNK_SIZE"u8; + + [NativeTypeName("#define SDL_HINT_WAVE_TRUNCATION \"SDL_WAVE_TRUNCATION\"")] + public static Utf8String HintWaveTruncation => "SDL_WAVE_TRUNCATION"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED \"SDL_WINDOW_ACTIVATE_WHEN_RAISED\"" + )] + public static Utf8String HintWindowActivateWhenRaised => "SDL_WINDOW_ACTIVATE_WHEN_RAISED"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOW_ACTIVATE_WHEN_SHOWN \"SDL_WINDOW_ACTIVATE_WHEN_SHOWN\"" + )] + public static Utf8String HintWindowActivateWhenShown => "SDL_WINDOW_ACTIVATE_WHEN_SHOWN"u8; + + [NativeTypeName("#define SDL_HINT_WINDOW_ALLOW_TOPMOST \"SDL_WINDOW_ALLOW_TOPMOST\"")] + public static Utf8String HintWindowAllowTopmost => "SDL_WINDOW_ALLOW_TOPMOST"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN \"SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN\"" + )] + public static Utf8String HintWindowFrameUsableWhileCursorHidden => + "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"u8; + + [NativeTypeName("#define SDL_HINT_WINDOWS_CLOSE_ON_ALT_F4 \"SDL_WINDOWS_CLOSE_ON_ALT_F4\"")] + public static Utf8String HintWindowsCloseOnAltF4 => "SDL_WINDOWS_CLOSE_ON_ALT_F4"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOWS_ENABLE_MENU_MNEMONICS \"SDL_WINDOWS_ENABLE_MENU_MNEMONICS\"" + )] + public static Utf8String HintWindowsEnableMenuMnemonics => + "SDL_WINDOWS_ENABLE_MENU_MNEMONICS"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP \"SDL_WINDOWS_ENABLE_MESSAGELOOP\"" + )] + public static Utf8String HintWindowsEnableMessageloop => "SDL_WINDOWS_ENABLE_MESSAGELOOP"u8; + + [NativeTypeName("#define SDL_HINT_WINDOWS_GAMEINPUT \"SDL_WINDOWS_GAMEINPUT\"")] + public static Utf8String HintWindowsGameinput => "SDL_WINDOWS_GAMEINPUT"u8; + + [NativeTypeName("#define SDL_HINT_WINDOWS_RAW_KEYBOARD \"SDL_WINDOWS_RAW_KEYBOARD\"")] + public static Utf8String HintWindowsRawKeyboard => "SDL_WINDOWS_RAW_KEYBOARD"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL \"SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL\"" + )] + public static Utf8String HintWindowsForceSemaphoreKernel => + "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"u8; + + [NativeTypeName("#define SDL_HINT_WINDOWS_INTRESOURCE_ICON \"SDL_WINDOWS_INTRESOURCE_ICON\"")] + public static Utf8String HintWindowsIntresourceIcon => "SDL_WINDOWS_INTRESOURCE_ICON"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL \"SDL_WINDOWS_INTRESOURCE_ICON_SMALL\"" + )] + public static Utf8String HintWindowsIntresourceIconSmall => + "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"u8; + + [NativeTypeName("#define SDL_HINT_WINDOWS_USE_D3D9EX \"SDL_WINDOWS_USE_D3D9EX\"")] + public static Utf8String HintWindowsUseD3D9Ex => "SDL_WINDOWS_USE_D3D9EX"u8; + + [NativeTypeName( + "#define SDL_HINT_WINDOWS_ERASE_BACKGROUND_MODE \"SDL_WINDOWS_ERASE_BACKGROUND_MODE\"" + )] + public static Utf8String HintWindowsEraseBackgroundMode => + "SDL_WINDOWS_ERASE_BACKGROUND_MODE"u8; + + [NativeTypeName( + "#define SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT \"SDL_X11_FORCE_OVERRIDE_REDIRECT\"" + )] + public static Utf8String HintX11ForceOverrideRedirect => "SDL_X11_FORCE_OVERRIDE_REDIRECT"u8; + + [NativeTypeName("#define SDL_HINT_X11_WINDOW_TYPE \"SDL_X11_WINDOW_TYPE\"")] + public static Utf8String HintX11WindowType => "SDL_X11_WINDOW_TYPE"u8; + + [NativeTypeName("#define SDL_HINT_X11_XCB_LIBRARY \"SDL_X11_XCB_LIBRARY\"")] + public static Utf8String HintX11XcbLibrary => "SDL_X11_XCB_LIBRARY"u8; + + [NativeTypeName("#define SDL_HINT_XINPUT_ENABLED \"SDL_XINPUT_ENABLED\"")] + public static Utf8String HintXinputEnabled => "SDL_XINPUT_ENABLED"u8; + + [NativeTypeName("#define SDL_HINT_ASSERT \"SDL_ASSERT\"")] + public static Utf8String HintAssert => "SDL_ASSERT"u8; + + [NativeTypeName("#define SDL_INIT_AUDIO 0x00000010u")] + public const uint InitAudio = 0x00000010U; + + [NativeTypeName("#define SDL_INIT_VIDEO 0x00000020u")] + public const uint InitVideo = 0x00000020U; + + [NativeTypeName("#define SDL_INIT_JOYSTICK 0x00000200u")] + public const uint InitJoystick = 0x00000200U; + + [NativeTypeName("#define SDL_INIT_HAPTIC 0x00001000u")] + public const uint InitHaptic = 0x00001000U; + + [NativeTypeName("#define SDL_INIT_GAMEPAD 0x00002000u")] + public const uint InitGamepad = 0x00002000U; + + [NativeTypeName("#define SDL_INIT_EVENTS 0x00004000u")] + public const uint InitEvents = 0x00004000U; + + [NativeTypeName("#define SDL_INIT_SENSOR 0x00008000u")] + public const uint InitSensor = 0x00008000U; + + [NativeTypeName("#define SDL_INIT_CAMERA 0x00010000u")] + public const uint InitCamera = 0x00010000U; + + [NativeTypeName("#define SDL_PROP_APP_METADATA_NAME_STRING \"SDL.app.metadata.name\"")] + public static Utf8String PropAppMetadataNameString => "SDL.app.metadata.name"u8; + + [NativeTypeName("#define SDL_PROP_APP_METADATA_VERSION_STRING \"SDL.app.metadata.version\"")] + public static Utf8String PropAppMetadataVersionString => "SDL.app.metadata.version"u8; + + [NativeTypeName( + "#define SDL_PROP_APP_METADATA_IDENTIFIER_STRING \"SDL.app.metadata.identifier\"" + )] + public static Utf8String PropAppMetadataIdentifierString => "SDL.app.metadata.identifier"u8; + + [NativeTypeName("#define SDL_PROP_APP_METADATA_CREATOR_STRING \"SDL.app.metadata.creator\"")] + public static Utf8String PropAppMetadataCreatorString => "SDL.app.metadata.creator"u8; + + [NativeTypeName( + "#define SDL_PROP_APP_METADATA_COPYRIGHT_STRING \"SDL.app.metadata.copyright\"" + )] + public static Utf8String PropAppMetadataCopyrightString => "SDL.app.metadata.copyright"u8; + + [NativeTypeName("#define SDL_PROP_APP_METADATA_URL_STRING \"SDL.app.metadata.url\"")] + public static Utf8String PropAppMetadataUrlString => "SDL.app.metadata.url"u8; + + [NativeTypeName("#define SDL_PROP_APP_METADATA_TYPE_STRING \"SDL.app.metadata.type\"")] + public static Utf8String PropAppMetadataTypeString => "SDL.app.metadata.type"u8; + + [NativeTypeName("#define SDL_MESSAGEBOX_ERROR 0x00000010u")] + public const uint MessageboxError = 0x00000010U; + + [NativeTypeName("#define SDL_MESSAGEBOX_WARNING 0x00000020u")] + public const uint MessageboxWarning = 0x00000020U; + + [NativeTypeName("#define SDL_MESSAGEBOX_INFORMATION 0x00000040u")] + public const uint MessageboxInformation = 0x00000040U; + + [NativeTypeName("#define SDL_MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT 0x00000080u")] + public const uint MessageboxButtonsLeftToRight = 0x00000080U; + + [NativeTypeName("#define SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT 0x00000100u")] + public const uint MessageboxButtonsRightToLeft = 0x00000100U; + + [NativeTypeName("#define SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT 0x00000001u")] + public const uint MessageboxButtonReturnkeyDefault = 0x00000001U; + + [NativeTypeName("#define SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT 0x00000002u")] + public const uint MessageboxButtonEscapekeyDefault = 0x00000002U; + + [NativeTypeName("#define SDL_PROP_PROCESS_CREATE_ARGS_POINTER \"SDL.process.create.args\"")] + public static Utf8String PropProcessCreateArgsPointer => "SDL.process.create.args"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_ENVIRONMENT_POINTER \"SDL.process.create.environment\"" + )] + public static Utf8String PropProcessCreateEnvironmentPointer => + "SDL.process.create.environment"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDIN_NUMBER \"SDL.process.create.stdin_option\"" + )] + public static Utf8String PropProcessCreateStdinNumber => "SDL.process.create.stdin_option"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDIN_POINTER \"SDL.process.create.stdin_source\"" + )] + public static Utf8String PropProcessCreateStdinPointer => "SDL.process.create.stdin_source"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDOUT_NUMBER \"SDL.process.create.stdout_option\"" + )] + public static Utf8String PropProcessCreateStdoutNumber => "SDL.process.create.stdout_option"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDOUT_POINTER \"SDL.process.create.stdout_source\"" + )] + public static Utf8String PropProcessCreateStdoutPointer => "SDL.process.create.stdout_source"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDERR_NUMBER \"SDL.process.create.stderr_option\"" + )] + public static Utf8String PropProcessCreateStderrNumber => "SDL.process.create.stderr_option"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDERR_POINTER \"SDL.process.create.stderr_source\"" + )] + public static Utf8String PropProcessCreateStderrPointer => "SDL.process.create.stderr_source"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_STDERR_TO_STDOUT_BOOLEAN \"SDL.process.create.stderr_to_stdout\"" + )] + public static Utf8String PropProcessCreateStderrToStdoutBoolean => + "SDL.process.create.stderr_to_stdout"u8; + + [NativeTypeName( + "#define SDL_PROP_PROCESS_CREATE_BACKGROUND_BOOLEAN \"SDL.process.create.background\"" + )] + public static Utf8String PropProcessCreateBackgroundBoolean => + "SDL.process.create.background"u8; + + [NativeTypeName("#define SDL_PROP_PROCESS_PID_NUMBER \"SDL.process.pid\"")] + public static Utf8String PropProcessPidNumber => "SDL.process.pid"u8; + + [NativeTypeName("#define SDL_PROP_PROCESS_STDIN_POINTER \"SDL.process.stdin\"")] + public static Utf8String PropProcessStdinPointer => "SDL.process.stdin"u8; + + [NativeTypeName("#define SDL_PROP_PROCESS_STDOUT_POINTER \"SDL.process.stdout\"")] + public static Utf8String PropProcessStdoutPointer => "SDL.process.stdout"u8; + + [NativeTypeName("#define SDL_PROP_PROCESS_STDERR_POINTER \"SDL.process.stderr\"")] + public static Utf8String PropProcessStderrPointer => "SDL.process.stderr"u8; + + [NativeTypeName("#define SDL_PROP_PROCESS_BACKGROUND_BOOLEAN \"SDL.process.background\"")] + public static Utf8String PropProcessBackgroundBoolean => "SDL.process.background"u8; + + [NativeTypeName("#define SDL_SOFTWARE_RENDERER \"software\"")] + public static Utf8String SoftwareRenderer => "software"u8; + + [NativeTypeName("#define SDL_PROP_RENDERER_CREATE_NAME_STRING \"SDL.renderer.create.name\"")] + public static Utf8String PropRendererCreateNameString => "SDL.renderer.create.name"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_WINDOW_POINTER \"SDL.renderer.create.window\"" + )] + public static Utf8String PropRendererCreateWindowPointer => "SDL.renderer.create.window"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_SURFACE_POINTER \"SDL.renderer.create.surface\"" + )] + public static Utf8String PropRendererCreateSurfacePointer => "SDL.renderer.create.surface"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER \"SDL.renderer.create.output_colorspace\"" + )] + public static Utf8String PropRendererCreateOutputColorspaceNumber => + "SDL.renderer.create.output_colorspace"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER \"SDL.renderer.create.present_vsync\"" + )] + public static Utf8String PropRendererCreatePresentVsyncNumber => + "SDL.renderer.create.present_vsync"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER \"SDL.renderer.create.vulkan.instance\"" + )] + public static Utf8String PropRendererCreateVulkanInstancePointer => + "SDL.renderer.create.vulkan.instance"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER \"SDL.renderer.create.vulkan.surface\"" + )] + public static Utf8String PropRendererCreateVulkanSurfaceNumber => + "SDL.renderer.create.vulkan.surface"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER \"SDL.renderer.create.vulkan.physical_device\"" + )] + public static Utf8String PropRendererCreateVulkanPhysicalDevicePointer => + "SDL.renderer.create.vulkan.physical_device"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER \"SDL.renderer.create.vulkan.device\"" + )] + public static Utf8String PropRendererCreateVulkanDevicePointer => + "SDL.renderer.create.vulkan.device"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.create.vulkan.graphics_queue_family_index\"" + )] + public static Utf8String PropRendererCreateVulkanGraphicsQueueFamilyIndexNumber => + "SDL.renderer.create.vulkan.graphics_queue_family_index"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.create.vulkan.present_queue_family_index\"" + )] + public static Utf8String PropRendererCreateVulkanPresentQueueFamilyIndexNumber => + "SDL.renderer.create.vulkan.present_queue_family_index"u8; + + [NativeTypeName("#define SDL_PROP_RENDERER_NAME_STRING \"SDL.renderer.name\"")] + public static Utf8String PropRendererNameString => "SDL.renderer.name"u8; + + [NativeTypeName("#define SDL_PROP_RENDERER_WINDOW_POINTER \"SDL.renderer.window\"")] + public static Utf8String PropRendererWindowPointer => "SDL.renderer.window"u8; + + [NativeTypeName("#define SDL_PROP_RENDERER_SURFACE_POINTER \"SDL.renderer.surface\"")] + public static Utf8String PropRendererSurfacePointer => "SDL.renderer.surface"u8; + + [NativeTypeName("#define SDL_PROP_RENDERER_VSYNC_NUMBER \"SDL.renderer.vsync\"")] + public static Utf8String PropRendererVsyncNumber => "SDL.renderer.vsync"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER \"SDL.renderer.max_texture_size\"" + )] + public static Utf8String PropRendererMaxTextureSizeNumber => "SDL.renderer.max_texture_size"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER \"SDL.renderer.texture_formats\"" + )] + public static Utf8String PropRendererTextureFormatsPointer => "SDL.renderer.texture_formats"u8; + + [NativeTypeName( + "#define SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER \"SDL.renderer.output_colorspace\"" + )] + public static Utf8String PropRendererOutputColorspaceNumber => + "SDL.renderer.output_colorspace"u8; - [NativeTypeName("#define SDLK_KP_EQUALS 0x40000067u")] - public const uint KKpEquals = 0x40000067U; + [NativeTypeName("#define SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN \"SDL.renderer.HDR_enabled\"")] + public static Utf8String PropRendererHdrEnabledBoolean => "SDL.renderer.HDR_enabled"u8; - [NativeTypeName("#define SDLK_F13 0x40000068u")] - public const uint KF13 = 0x40000068U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT \"SDL.renderer.SDR_white_point\"" + )] + public static Utf8String PropRendererSdrWhitePointFloat => "SDL.renderer.SDR_white_point"u8; - [NativeTypeName("#define SDLK_F14 0x40000069u")] - public const uint KF14 = 0x40000069U; + [NativeTypeName("#define SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT \"SDL.renderer.HDR_headroom\"")] + public static Utf8String PropRendererHdrHeadroomFloat => "SDL.renderer.HDR_headroom"u8; - [NativeTypeName("#define SDLK_F15 0x4000006au")] - public const uint KF15 = 0x4000006aU; + [NativeTypeName("#define SDL_PROP_RENDERER_D3D9_DEVICE_POINTER \"SDL.renderer.d3d9.device\"")] + public static Utf8String PropRendererD3D9DevicePointer => "SDL.renderer.d3d9.device"u8; - [NativeTypeName("#define SDLK_F16 0x4000006bu")] - public const uint KF16 = 0x4000006bU; + [NativeTypeName("#define SDL_PROP_RENDERER_D3D11_DEVICE_POINTER \"SDL.renderer.d3d11.device\"")] + public static Utf8String PropRendererD3D11DevicePointer => "SDL.renderer.d3d11.device"u8; - [NativeTypeName("#define SDLK_F17 0x4000006cu")] - public const uint KF17 = 0x4000006cU; + [NativeTypeName( + "#define SDL_PROP_RENDERER_D3D11_SWAPCHAIN_POINTER \"SDL.renderer.d3d11.swap_chain\"" + )] + public static Utf8String PropRendererD3D11SwapchainPointer => "SDL.renderer.d3d11.swap_chain"u8; - [NativeTypeName("#define SDLK_F18 0x4000006du")] - public const uint KF18 = 0x4000006dU; + [NativeTypeName("#define SDL_PROP_RENDERER_D3D12_DEVICE_POINTER \"SDL.renderer.d3d12.device\"")] + public static Utf8String PropRendererD3D12DevicePointer => "SDL.renderer.d3d12.device"u8; - [NativeTypeName("#define SDLK_F19 0x4000006eu")] - public const uint KF19 = 0x4000006eU; + [NativeTypeName( + "#define SDL_PROP_RENDERER_D3D12_SWAPCHAIN_POINTER \"SDL.renderer.d3d12.swap_chain\"" + )] + public static Utf8String PropRendererD3D12SwapchainPointer => "SDL.renderer.d3d12.swap_chain"u8; - [NativeTypeName("#define SDLK_F20 0x4000006fu")] - public const uint KF20 = 0x4000006fU; + [NativeTypeName( + "#define SDL_PROP_RENDERER_D3D12_COMMAND_QUEUE_POINTER \"SDL.renderer.d3d12.command_queue\"" + )] + public static Utf8String PropRendererD3D12CommandQueuePointer => + "SDL.renderer.d3d12.command_queue"u8; - [NativeTypeName("#define SDLK_F21 0x40000070u")] - public const uint KF21 = 0x40000070U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_INSTANCE_POINTER \"SDL.renderer.vulkan.instance\"" + )] + public static Utf8String PropRendererVulkanInstancePointer => "SDL.renderer.vulkan.instance"u8; - [NativeTypeName("#define SDLK_F22 0x40000071u")] - public const uint KF22 = 0x40000071U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_SURFACE_NUMBER \"SDL.renderer.vulkan.surface\"" + )] + public static Utf8String PropRendererVulkanSurfaceNumber => "SDL.renderer.vulkan.surface"u8; - [NativeTypeName("#define SDLK_F23 0x40000072u")] - public const uint KF23 = 0x40000072U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_PHYSICAL_DEVICE_POINTER \"SDL.renderer.vulkan.physical_device\"" + )] + public static Utf8String PropRendererVulkanPhysicalDevicePointer => + "SDL.renderer.vulkan.physical_device"u8; - [NativeTypeName("#define SDLK_F24 0x40000073u")] - public const uint KF24 = 0x40000073U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_DEVICE_POINTER \"SDL.renderer.vulkan.device\"" + )] + public static Utf8String PropRendererVulkanDevicePointer => "SDL.renderer.vulkan.device"u8; - [NativeTypeName("#define SDLK_EXECUTE 0x40000074u")] - public const uint KExecute = 0x40000074U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.vulkan.graphics_queue_family_index\"" + )] + public static Utf8String PropRendererVulkanGraphicsQueueFamilyIndexNumber => + "SDL.renderer.vulkan.graphics_queue_family_index"u8; - [NativeTypeName("#define SDLK_HELP 0x40000075u")] - public const uint KHelp = 0x40000075U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.vulkan.present_queue_family_index\"" + )] + public static Utf8String PropRendererVulkanPresentQueueFamilyIndexNumber => + "SDL.renderer.vulkan.present_queue_family_index"u8; - [NativeTypeName("#define SDLK_MENU 0x40000076u")] - public const uint KMenu = 0x40000076U; + [NativeTypeName( + "#define SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER \"SDL.renderer.vulkan.swapchain_image_count\"" + )] + public static Utf8String PropRendererVulkanSwapchainImageCountNumber => + "SDL.renderer.vulkan.swapchain_image_count"u8; - [NativeTypeName("#define SDLK_SELECT 0x40000077u")] - public const uint KSelect = 0x40000077U; + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER \"SDL.texture.create.colorspace\"" + )] + public static Utf8String PropTextureCreateColorspaceNumber => "SDL.texture.create.colorspace"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER \"SDL.texture.create.format\"")] + public static Utf8String PropTextureCreateFormatNumber => "SDL.texture.create.format"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER \"SDL.texture.create.access\"")] + public static Utf8String PropTextureCreateAccessNumber => "SDL.texture.create.access"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER \"SDL.texture.create.width\"")] + public static Utf8String PropTextureCreateWidthNumber => "SDL.texture.create.width"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER \"SDL.texture.create.height\"")] + public static Utf8String PropTextureCreateHeightNumber => "SDL.texture.create.height"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT \"SDL.texture.create.SDR_white_point\"" + )] + public static Utf8String PropTextureCreateSdrWhitePointFloat => + "SDL.texture.create.SDR_white_point"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT \"SDL.texture.create.HDR_headroom\"" + )] + public static Utf8String PropTextureCreateHdrHeadroomFloat => + "SDL.texture.create.HDR_headroom"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_POINTER \"SDL.texture.create.d3d11.texture\"" + )] + public static Utf8String PropTextureCreateD3D11TexturePointer => + "SDL.texture.create.d3d11.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_U_POINTER \"SDL.texture.create.d3d11.texture_u\"" + )] + public static Utf8String PropTextureCreateD3D11TextureUPointer => + "SDL.texture.create.d3d11.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_V_POINTER \"SDL.texture.create.d3d11.texture_v\"" + )] + public static Utf8String PropTextureCreateD3D11TextureVPointer => + "SDL.texture.create.d3d11.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_POINTER \"SDL.texture.create.d3d12.texture\"" + )] + public static Utf8String PropTextureCreateD3D12TexturePointer => + "SDL.texture.create.d3d12.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_U_POINTER \"SDL.texture.create.d3d12.texture_u\"" + )] + public static Utf8String PropTextureCreateD3D12TextureUPointer => + "SDL.texture.create.d3d12.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_V_POINTER \"SDL.texture.create.d3d12.texture_v\"" + )] + public static Utf8String PropTextureCreateD3D12TextureVPointer => + "SDL.texture.create.d3d12.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_METAL_PIXELBUFFER_POINTER \"SDL.texture.create.metal.pixelbuffer\"" + )] + public static Utf8String PropTextureCreateMetalPixelbufferPointer => + "SDL.texture.create.metal.pixelbuffer"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER \"SDL.texture.create.opengl.texture\"" + )] + public static Utf8String PropTextureCreateOpenglTextureNumber => + "SDL.texture.create.opengl.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER \"SDL.texture.create.opengl.texture_uv\"" + )] + public static Utf8String PropTextureCreateOpenglTextureUvNumber => + "SDL.texture.create.opengl.texture_uv"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER \"SDL.texture.create.opengl.texture_u\"" + )] + public static Utf8String PropTextureCreateOpenglTextureUNumber => + "SDL.texture.create.opengl.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER \"SDL.texture.create.opengl.texture_v\"" + )] + public static Utf8String PropTextureCreateOpenglTextureVNumber => + "SDL.texture.create.opengl.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER \"SDL.texture.create.opengles2.texture\"" + )] + public static Utf8String PropTextureCreateOpengles2TextureNumber => + "SDL.texture.create.opengles2.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER \"SDL.texture.create.opengles2.texture_uv\"" + )] + public static Utf8String PropTextureCreateOpengles2TextureUvNumber => + "SDL.texture.create.opengles2.texture_uv"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER \"SDL.texture.create.opengles2.texture_u\"" + )] + public static Utf8String PropTextureCreateOpengles2TextureUNumber => + "SDL.texture.create.opengles2.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER \"SDL.texture.create.opengles2.texture_v\"" + )] + public static Utf8String PropTextureCreateOpengles2TextureVNumber => + "SDL.texture.create.opengles2.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER \"SDL.texture.create.vulkan.texture\"" + )] + public static Utf8String PropTextureCreateVulkanTextureNumber => + "SDL.texture.create.vulkan.texture"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_COLORSPACE_NUMBER \"SDL.texture.colorspace\"")] + public static Utf8String PropTextureColorspaceNumber => "SDL.texture.colorspace"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_FORMAT_NUMBER \"SDL.texture.format\"")] + public static Utf8String PropTextureFormatNumber => "SDL.texture.format"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_ACCESS_NUMBER \"SDL.texture.access\"")] + public static Utf8String PropTextureAccessNumber => "SDL.texture.access"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_WIDTH_NUMBER \"SDL.texture.width\"")] + public static Utf8String PropTextureWidthNumber => "SDL.texture.width"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_HEIGHT_NUMBER \"SDL.texture.height\"")] + public static Utf8String PropTextureHeightNumber => "SDL.texture.height"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_SDR_WHITE_POINT_FLOAT \"SDL.texture.SDR_white_point\"" + )] + public static Utf8String PropTextureSdrWhitePointFloat => "SDL.texture.SDR_white_point"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_HDR_HEADROOM_FLOAT \"SDL.texture.HDR_headroom\"")] + public static Utf8String PropTextureHdrHeadroomFloat => "SDL.texture.HDR_headroom"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_D3D11_TEXTURE_POINTER \"SDL.texture.d3d11.texture\"")] + public static Utf8String PropTextureD3D11TexturePointer => "SDL.texture.d3d11.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_D3D11_TEXTURE_U_POINTER \"SDL.texture.d3d11.texture_u\"" + )] + public static Utf8String PropTextureD3D11TextureUPointer => "SDL.texture.d3d11.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_D3D11_TEXTURE_V_POINTER \"SDL.texture.d3d11.texture_v\"" + )] + public static Utf8String PropTextureD3D11TextureVPointer => "SDL.texture.d3d11.texture_v"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_D3D12_TEXTURE_POINTER \"SDL.texture.d3d12.texture\"")] + public static Utf8String PropTextureD3D12TexturePointer => "SDL.texture.d3d12.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_D3D12_TEXTURE_U_POINTER \"SDL.texture.d3d12.texture_u\"" + )] + public static Utf8String PropTextureD3D12TextureUPointer => "SDL.texture.d3d12.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_D3D12_TEXTURE_V_POINTER \"SDL.texture.d3d12.texture_v\"" + )] + public static Utf8String PropTextureD3D12TextureVPointer => "SDL.texture.d3d12.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER \"SDL.texture.opengl.texture\"" + )] + public static Utf8String PropTextureOpenglTextureNumber => "SDL.texture.opengl.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_UV_NUMBER \"SDL.texture.opengl.texture_uv\"" + )] + public static Utf8String PropTextureOpenglTextureUvNumber => "SDL.texture.opengl.texture_uv"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_U_NUMBER \"SDL.texture.opengl.texture_u\"" + )] + public static Utf8String PropTextureOpenglTextureUNumber => "SDL.texture.opengl.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_V_NUMBER \"SDL.texture.opengl.texture_v\"" + )] + public static Utf8String PropTextureOpenglTextureVNumber => "SDL.texture.opengl.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER \"SDL.texture.opengl.target\"" + )] + public static Utf8String PropTextureOpenglTextureTargetNumber => "SDL.texture.opengl.target"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_OPENGL_TEX_W_FLOAT \"SDL.texture.opengl.tex_w\"")] + public static Utf8String PropTextureOpenglTexWFloat => "SDL.texture.opengl.tex_w"u8; + + [NativeTypeName("#define SDL_PROP_TEXTURE_OPENGL_TEX_H_FLOAT \"SDL.texture.opengl.tex_h\"")] + public static Utf8String PropTextureOpenglTexHFloat => "SDL.texture.opengl.tex_h"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_NUMBER \"SDL.texture.opengles2.texture\"" + )] + public static Utf8String PropTextureOpengles2TextureNumber => "SDL.texture.opengles2.texture"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_UV_NUMBER \"SDL.texture.opengles2.texture_uv\"" + )] + public static Utf8String PropTextureOpengles2TextureUvNumber => + "SDL.texture.opengles2.texture_uv"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_U_NUMBER \"SDL.texture.opengles2.texture_u\"" + )] + public static Utf8String PropTextureOpengles2TextureUNumber => + "SDL.texture.opengles2.texture_u"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_V_NUMBER \"SDL.texture.opengles2.texture_v\"" + )] + public static Utf8String PropTextureOpengles2TextureVNumber => + "SDL.texture.opengles2.texture_v"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_TARGET_NUMBER \"SDL.texture.opengles2.target\"" + )] + public static Utf8String PropTextureOpengles2TextureTargetNumber => + "SDL.texture.opengles2.target"u8; + + [NativeTypeName( + "#define SDL_PROP_TEXTURE_VULKAN_TEXTURE_NUMBER \"SDL.texture.vulkan.texture\"" + )] + public static Utf8String PropTextureVulkanTextureNumber => "SDL.texture.vulkan.texture"u8; + + [NativeTypeName("#define SDL_RENDERER_VSYNC_DISABLED 0")] + public const int RendererVsyncDisabled = 0; + + [NativeTypeName("#define SDL_RENDERER_VSYNC_ADAPTIVE (-1)")] + public const int RendererVsyncAdaptive = (-1); + + [NativeTypeName("#define SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE 8")] + public const int DebugTextFontCharacterSize = 8; + + [NativeTypeName("#define SDL_MS_PER_SECOND 1000")] + public const int MsPerSecond = 1000; + + [NativeTypeName("#define SDL_US_PER_SECOND 1000000")] + public const int UsPerSecond = 1000000; + + [NativeTypeName("#define SDL_NS_PER_SECOND 1000000000LL")] + public const long NsPerSecond = 1000000000L; + + [NativeTypeName("#define SDL_NS_PER_MS 1000000")] + public const int NsPerMs = 1000000; + + [NativeTypeName("#define SDL_NS_PER_US 1000")] + public const int NsPerUs = 1000; + + [NativeTypeName("#define SDL_MAJOR_VERSION 3")] + public const int MajorVersion = 3; + + [NativeTypeName("#define SDL_MINOR_VERSION 1")] + public const int MinorVersion = 1; + + [NativeTypeName("#define SDL_MICRO_VERSION 6")] + public const int MicroVersion = 6; + + [NativeTypeName( + "#define SDL_VERSION SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_MICRO_VERSION)" + )] + public const int Version = ((3) * 1000000 + (1) * 1000 + (6)); + + public static bool PointInRect( + [NativeTypeName("const SDL_Point *")] Point* p, + [NativeTypeName("const SDL_Rect *")] Rect* r + ) + { + return ( + (p) != null + && (r) != null + && (p->X >= r->X) + && (p->X < (r->X + r->W)) + && (p->Y >= r->Y) + && (p->Y < (r->Y + r->H)) + ) + ? true + : false; + } + + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool PointInRect( + [NativeTypeName("const SDL_Point *")] Ref p, + [NativeTypeName("const SDL_Rect *")] Ref r + ) + { + fixed (Rect* __dsl_r = r) + fixed (Point* __dsl_p = p) + { + return (bool)PointInRect(__dsl_p, __dsl_r); + } + } + + public static bool PointInRectFloat( + [NativeTypeName("const SDL_FPoint *")] FPoint* p, + [NativeTypeName("const SDL_FRect *")] FRect* r + ) + { + return ( + (p) != null + && (r) != null + && (p->X >= r->X) + && (p->X <= (r->X + r->W)) + && (p->Y >= r->Y) + && (p->Y <= (r->Y + r->H)) + ) + ? true + : false; + } + + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool PointInRectFloat( + [NativeTypeName("const SDL_FPoint *")] Ref p, + [NativeTypeName("const SDL_FRect *")] Ref r + ) + { + fixed (FRect* __dsl_r = r) + fixed (FPoint* __dsl_p = p) + { + return (bool)PointInRectFloat(__dsl_p, __dsl_r); + } + } + + public static bool RectEmpty([NativeTypeName("const SDL_Rect *")] Rect* r) + { + return ((r == null) || (r->W <= 0) || (r->H <= 0)) ? true : false; + } + + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool RectEmpty([NativeTypeName("const SDL_Rect *")] Ref r) + { + fixed (Rect* __dsl_r = r) + { + return (bool)RectEmpty(__dsl_r); + } + } + + public static bool RectEmptyFloat([NativeTypeName("const SDL_FRect *")] FRect* r) + { + return ((r == null) || (r->W < 0.0f) || (r->H < 0.0f)) ? true : false; + } + + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool RectEmptyFloat([NativeTypeName("const SDL_FRect *")] Ref r) + { + fixed (FRect* __dsl_r = r) + { + return (bool)RectEmptyFloat(__dsl_r); + } + } + + public static bool RectsEqual( + [NativeTypeName("const SDL_Rect *")] Rect* a, + [NativeTypeName("const SDL_Rect *")] Rect* b + ) + { + return ( + (a) != null + && (b) != null + && (a->X == b->X) + && (a->Y == b->Y) + && (a->W == b->W) + && (a->H == b->H) + ) + ? true + : false; + } + + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool RectsEqual( + [NativeTypeName("const SDL_Rect *")] Ref a, + [NativeTypeName("const SDL_Rect *")] Ref b + ) + { + fixed (Rect* __dsl_b = b) + fixed (Rect* __dsl_a = a) + { + return (bool)RectsEqual(__dsl_a, __dsl_b); + } + } + + public static bool RectsEqualEpsilon( + [NativeTypeName("const SDL_FRect *")] FRect* a, + [NativeTypeName("const SDL_FRect *")] FRect* b, + [NativeTypeName("const float")] float epsilon + ) + { + return ( + (a) != null + && (b) != null + && ( + (a == b) + || ( + (float.Abs(a->X - b->X) <= epsilon) + && (float.Abs(a->Y - b->Y) <= epsilon) + && (float.Abs(a->W - b->W) <= epsilon) + && (float.Abs(a->H - b->H) <= epsilon) + ) + ) + ) + ? true + : false; + } - [NativeTypeName("#define SDLK_STOP 0x40000078u")] - public const uint KStop = 0x40000078U; + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool RectsEqualEpsilon( + [NativeTypeName("const SDL_FRect *")] Ref a, + [NativeTypeName("const SDL_FRect *")] Ref b, + [NativeTypeName("const float")] float epsilon + ) + { + fixed (FRect* __dsl_b = b) + fixed (FRect* __dsl_a = a) + { + return (bool)RectsEqualEpsilon(__dsl_a, __dsl_b, epsilon); + } + } - [NativeTypeName("#define SDLK_AGAIN 0x40000079u")] - public const uint KAgain = 0x40000079U; + public static bool RectsEqualFloat( + [NativeTypeName("const SDL_FRect *")] FRect* a, + [NativeTypeName("const SDL_FRect *")] FRect* b + ) + { + return RectsEqualEpsilon(a, b, 1.1920928955078125e-07F); + } - [NativeTypeName("#define SDLK_UNDO 0x4000007au")] - public const uint KUndo = 0x4000007aU; + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool RectsEqualFloat( + [NativeTypeName("const SDL_FRect *")] Ref a, + [NativeTypeName("const SDL_FRect *")] Ref b + ) + { + fixed (FRect* __dsl_b = b) + fixed (FRect* __dsl_a = a) + { + return (bool)RectsEqualFloat(__dsl_a, __dsl_b); + } + } - [NativeTypeName("#define SDLK_CUT 0x4000007bu")] - public const uint KCut = 0x4000007bU; + public static void RectToFRect([NativeTypeName("const SDL_Rect *")] Rect* rect, FRect* frect) + { + frect->X = (float)(rect->X); + frect->Y = (float)(rect->Y); + frect->W = (float)(rect->W); + frect->H = (float)(rect->H); + } - [NativeTypeName("#define SDLK_COPY 0x4000007cu")] - public const uint KCopy = 0x4000007cU; + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void RectToFRect( + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref frect + ) + { + fixed (FRect* __dsl_frect = frect) + fixed (Rect* __dsl_rect = rect) + { + RectToFRect(__dsl_rect, __dsl_frect); + } + } - [NativeTypeName("#define SDLK_PASTE 0x4000007du")] - public const uint KPaste = 0x4000007dU; + public static bool SizeAddCheckOverflow( + [NativeTypeName("size_t")] nuint a, + [NativeTypeName("size_t")] nuint b, + [NativeTypeName("size_t *")] nuint* ret + ) + { + if (b > 18446744073709551615U - a) + { + return false; + } + *ret = a + b; + return true; + } - [NativeTypeName("#define SDLK_FIND 0x4000007eu")] - public const uint KFind = 0x4000007eU; + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool SizeAddCheckOverflow( + [NativeTypeName("size_t")] nuint a, + [NativeTypeName("size_t")] nuint b, + [NativeTypeName("size_t *")] Ref ret + ) + { + fixed (nuint* __dsl_ret = ret) + { + return (bool)SizeAddCheckOverflow(a, b, __dsl_ret); + } + } - [NativeTypeName("#define SDLK_MUTE 0x4000007fu")] - public const uint KMute = 0x4000007fU; + public static bool SizeMulCheckOverflow( + [NativeTypeName("size_t")] nuint a, + [NativeTypeName("size_t")] nuint b, + [NativeTypeName("size_t *")] nuint* ret + ) + { + if (a != 0 && b > 18446744073709551615U / a) + { + return false; + } + *ret = a * b; + return true; + } - [NativeTypeName("#define SDLK_VOLUMEUP 0x40000080u")] - public const uint KVolumeup = 0x40000080U; + [Transformed] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static bool SizeMulCheckOverflow( + [NativeTypeName("size_t")] nuint a, + [NativeTypeName("size_t")] nuint b, + [NativeTypeName("size_t *")] Ref ret + ) + { + fixed (nuint* __dsl_ret = ret) + { + return (bool)SizeMulCheckOverflow(a, b, __dsl_ret); + } + } - [NativeTypeName("#define SDLK_VOLUMEDOWN 0x40000081u")] - public const uint KVolumedown = 0x40000081U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Abs(int x) => + ( + (delegate* unmanaged)( + _slots[0] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[0] = nativeContext.LoadFunction("SDL_abs", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_KP_COMMA 0x40000085u")] - public const uint KKpComma = 0x40000085U; + [NativeFunction("SDL3", EntryPoint = "SDL_abs")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Abs(int x) => DllImport.Abs(x); - [NativeTypeName("#define SDLK_KP_EQUALSAS400 0x40000086u")] - public const uint KKpEqualsas400 = 0x40000086U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Acos(double x) => + ( + (delegate* unmanaged)( + _slots[1] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1] = nativeContext.LoadFunction("SDL_acos", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_ALTERASE 0x40000099u")] - public const uint KAlterase = 0x40000099U; + [NativeFunction("SDL3", EntryPoint = "SDL_acos")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Acos(double x) => DllImport.Acos(x); - [NativeTypeName("#define SDLK_SYSREQ 0x4000009au")] - public const uint KSysreq = 0x4000009aU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Acosf(float x) => + ( + (delegate* unmanaged)( + _slots[2] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[2] = nativeContext.LoadFunction("SDL_acosf", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_CANCEL 0x4000009bu")] - public const uint KCancel = 0x4000009bU; + [NativeFunction("SDL3", EntryPoint = "SDL_acosf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Acosf(float x) => DllImport.Acosf(x); - [NativeTypeName("#define SDLK_CLEAR 0x4000009cu")] - public const uint KClear = 0x4000009cU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] ulong* timestampNS + ) => + ( + (delegate* unmanaged)( + _slots[3] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[3] = nativeContext.LoadFunction("SDL_AcquireCameraFrame", "SDL3") + ) + )(camera, timestampNS); - [NativeTypeName("#define SDLK_PRIOR 0x4000009du")] - public const uint KPrior = 0x4000009dU; + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] ulong* timestampNS + ) => DllImport.AcquireCameraFrame(camera, timestampNS); - [NativeTypeName("#define SDLK_RETURN2 0x4000009eu")] - public const uint KReturn2 = 0x4000009eU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] Ref timestampNS + ) + { + fixed (ulong* __dsl_timestampNS = timestampNS) + { + return (Surface*)((ISdl)this).AcquireCameraFrame(camera, __dsl_timestampNS); + } + } - [NativeTypeName("#define SDLK_SEPARATOR 0x4000009fu")] - public const uint KSeparator = 0x4000009fU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr AcquireCameraFrame( + CameraHandle camera, + [NativeTypeName("Uint64 *")] Ref timestampNS + ) => DllImport.AcquireCameraFrame(camera, timestampNS); - [NativeTypeName("#define SDLK_OUT 0x400000a0u")] - public const uint KOut = 0x400000a0U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUCommandBufferHandle ISdl.AcquireGPUCommandBuffer(GPUDeviceHandle device) => + ( + (delegate* unmanaged)( + _slots[4] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[4] = nativeContext.LoadFunction("SDL_AcquireGPUCommandBuffer", "SDL3") + ) + )(device); - [NativeTypeName("#define SDLK_OPER 0x400000a1u")] - public const uint KOper = 0x400000a1U; + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUCommandBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUCommandBufferHandle AcquireGPUCommandBuffer(GPUDeviceHandle device) => + DllImport.AcquireGPUCommandBuffer(device); - [NativeTypeName("#define SDLK_CLEARAGAIN 0x400000a2u")] - public const uint KClearagain = 0x400000a2U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ) => + ( + (delegate* unmanaged< + GPUCommandBufferHandle, + WindowHandle, + GPUTextureHandle*, + uint*, + uint*, + byte>)( + _slots[5] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[5] = nativeContext.LoadFunction( + "SDL_AcquireGPUSwapchainTexture", + "SDL3" + ) + ) + )( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); - [NativeTypeName("#define SDLK_CRSEL 0x400000a3u")] - public const uint KCrsel = 0x400000a3U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + GPUTextureHandle* swapchain_texture, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_width, + [NativeTypeName("Uint32 *")] uint* swapchain_texture_height + ) => + DllImport.AcquireGPUSwapchainTexture( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); - [NativeTypeName("#define SDLK_EXSEL 0x400000a4u")] - public const uint KExsel = 0x400000a4U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ) + { + fixed (uint* __dsl_swapchain_texture_height = swapchain_texture_height) + fixed (uint* __dsl_swapchain_texture_width = swapchain_texture_width) + fixed (GPUTextureHandle* __dsl_swapchain_texture = swapchain_texture) + { + return (MaybeBool) + (byte) + ((ISdl)this).AcquireGPUSwapchainTexture( + command_buffer, + window, + __dsl_swapchain_texture, + __dsl_swapchain_texture_width, + __dsl_swapchain_texture_height + ); + } + } - [NativeTypeName("#define SDLK_KP_00 0x400000b0u")] - public const uint KKp00 = 0x400000b0U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AcquireGPUSwapchainTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AcquireGPUSwapchainTexture( + GPUCommandBufferHandle command_buffer, + WindowHandle window, + Ref swapchain_texture, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_width, + [NativeTypeName("Uint32 *")] Ref swapchain_texture_height + ) => + DllImport.AcquireGPUSwapchainTexture( + command_buffer, + window, + swapchain_texture, + swapchain_texture_width, + swapchain_texture_height + ); - [NativeTypeName("#define SDLK_KP_000 0x400000b1u")] - public const uint KKp000 = 0x400000b1U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddAtomicInt(AtomicInt* a, int v) => + ( + (delegate* unmanaged)( + _slots[6] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[6] = nativeContext.LoadFunction("SDL_AddAtomicInt", "SDL3") + ) + )(a, v); - [NativeTypeName("#define SDLK_THOUSANDSSEPARATOR 0x400000b2u")] - public const uint KThousandsseparator = 0x400000b2U; + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddAtomicInt(AtomicInt* a, int v) => DllImport.AddAtomicInt(a, v); - [NativeTypeName("#define SDLK_DECIMALSEPARATOR 0x400000b3u")] - public const uint KDecimalseparator = 0x400000b3U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddAtomicInt(Ref a, int v) + { + fixed (AtomicInt* __dsl_a = a) + { + return (int)((ISdl)this).AddAtomicInt(__dsl_a, v); + } + } - [NativeTypeName("#define SDLK_CURRENCYUNIT 0x400000b4u")] - public const uint KCurrencyunit = 0x400000b4U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddAtomicInt(Ref a, int v) => DllImport.AddAtomicInt(a, v); - [NativeTypeName("#define SDLK_CURRENCYSUBUNIT 0x400000b5u")] - public const uint KCurrencysubunit = 0x400000b5U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[7] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[7] = nativeContext.LoadFunction("SDL_AddEventWatch", "SDL3") + ) + )(filter, userdata); - [NativeTypeName("#define SDLK_KP_LEFTPAREN 0x400000b6u")] - public const uint KKpLeftparen = 0x400000b6U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => DllImport.AddEventWatch(filter, userdata); - [NativeTypeName("#define SDLK_KP_RIGHTPAREN 0x400000b7u")] - public const uint KKpRightparen = 0x400000b7U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool)(byte)((ISdl)this).AddEventWatch(filter, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_LEFTBRACE 0x400000b8u")] - public const uint KKpLeftbrace = 0x400000b8U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AddEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => DllImport.AddEventWatch(filter, userdata); - [NativeTypeName("#define SDLK_KP_RIGHTBRACE 0x400000b9u")] - public const uint KKpRightbrace = 0x400000b9U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => + ( + (delegate* unmanaged)( + _slots[8] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[8] = nativeContext.LoadFunction("SDL_AddGamepadMapping", "SDL3") + ) + )(mapping); - [NativeTypeName("#define SDLK_KP_TAB 0x400000bau")] - public const uint KKpTab = 0x400000baU; + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => + DllImport.AddGamepadMapping(mapping); - [NativeTypeName("#define SDLK_KP_BACKSPACE 0x400000bbu")] - public const uint KKpBackspace = 0x400000bbU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) + { + fixed (sbyte* __dsl_mapping = mapping) + { + return (int)((ISdl)this).AddGamepadMapping(__dsl_mapping); + } + } - [NativeTypeName("#define SDLK_KP_A 0x400000bcu")] - public const uint KKpA = 0x400000bcU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) => + DllImport.AddGamepadMapping(mapping); - [NativeTypeName("#define SDLK_KP_B 0x400000bdu")] - public const uint KKpB = 0x400000bdU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => + ( + (delegate* unmanaged)( + _slots[9] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[9] = nativeContext.LoadFunction( + "SDL_AddGamepadMappingsFromFile", + "SDL3" + ) + ) + )(file); - [NativeTypeName("#define SDLK_KP_C 0x400000beu")] - public const uint KKpC = 0x400000beU; + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => + DllImport.AddGamepadMappingsFromFile(file); - [NativeTypeName("#define SDLK_KP_D 0x400000bfu")] - public const uint KKpD = 0x400000bfU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMappingsFromFile([NativeTypeName("const char *")] Ref file) + { + fixed (sbyte* __dsl_file = file) + { + return (int)((ISdl)this).AddGamepadMappingsFromFile(__dsl_file); + } + } - [NativeTypeName("#define SDLK_KP_E 0x400000c0u")] - public const uint KKpE = 0x400000c0U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMappingsFromFile( + [NativeTypeName("const char *")] Ref file + ) => DllImport.AddGamepadMappingsFromFile(file); - [NativeTypeName("#define SDLK_KP_F 0x400000c1u")] - public const uint KKpF = 0x400000c1U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMappingsFromIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => + ( + (delegate* unmanaged)( + _slots[10] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[10] = nativeContext.LoadFunction( + "SDL_AddGamepadMappingsFromIO", + "SDL3" + ) + ) + )(src, closeio); - [NativeTypeName("#define SDLK_KP_XOR 0x400000c2u")] - public const uint KKpXor = 0x400000c2U; + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio + ) => DllImport.AddGamepadMappingsFromIO(src, closeio); - [NativeTypeName("#define SDLK_KP_POWER 0x400000c3u")] - public const uint KKpPower = 0x400000c3U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => (int)((ISdl)this).AddGamepadMappingsFromIO(src, (byte)closeio); - [NativeTypeName("#define SDLK_KP_PERCENT 0x400000c4u")] - public const uint KKpPercent = 0x400000c4U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int AddGamepadMappingsFromIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => DllImport.AddGamepadMappingsFromIO(src, closeio); - [NativeTypeName("#define SDLK_KP_LESS 0x400000c5u")] - public const uint KKpLess = 0x400000c5U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AddHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[11] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[11] = nativeContext.LoadFunction("SDL_AddHintCallback", "SDL3") + ) + )(name, callback, userdata); - [NativeTypeName("#define SDLK_KP_GREATER 0x400000c6u")] - public const uint KKpGreater = 0x400000c6U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AddHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => DllImport.AddHintCallback(name, callback, userdata); - [NativeTypeName("#define SDLK_KP_AMPERSAND 0x400000c7u")] - public const uint KKpAmpersand = 0x400000c7U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AddHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)((ISdl)this).AddHintCallback(__dsl_name, callback, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_DBLAMPERSAND 0x400000c8u")] - public const uint KKpDblampersand = 0x400000c8U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AddHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) => DllImport.AddHintCallback(name, callback, userdata); - [NativeTypeName("#define SDLK_KP_VERTICALBAR 0x400000c9u")] - public const uint KKpVerticalbar = 0x400000c9U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AddSurfaceAlternateImage(Surface* surface, Surface* image) => + ( + (delegate* unmanaged)( + _slots[12] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[12] = nativeContext.LoadFunction( + "SDL_AddSurfaceAlternateImage", + "SDL3" + ) + ) + )(surface, image); - [NativeTypeName("#define SDLK_KP_DBLVERTICALBAR 0x400000cau")] - public const uint KKpDblverticalbar = 0x400000caU; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => + DllImport.AddSurfaceAlternateImage(surface, image); - [NativeTypeName("#define SDLK_KP_COLON 0x400000cbu")] - public const uint KKpColon = 0x400000cbU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AddSurfaceAlternateImage(Ref surface, Ref image) + { + fixed (Surface* __dsl_image = image) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).AddSurfaceAlternateImage(__dsl_surface, __dsl_image); + } + } - [NativeTypeName("#define SDLK_KP_HASH 0x400000ccu")] - public const uint KKpHash = 0x400000ccU; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AddSurfaceAlternateImage( + Ref surface, + Ref image + ) => DllImport.AddSurfaceAlternateImage(surface, image); - [NativeTypeName("#define SDLK_KP_SPACE 0x400000cdu")] - public const uint KKpSpace = 0x400000cdU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[13] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[13] = nativeContext.LoadFunction("SDL_AddTimer", "SDL3") + ) + )(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_AT 0x400000ceu")] - public const uint KKpAt = 0x400000ceU; + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + void* userdata + ) => DllImport.AddTimer(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_EXCLAM 0x400000cfu")] - public const uint KKpExclam = 0x400000cfU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (uint)((ISdl)this).AddTimer(interval, callback, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_MEMSTORE 0x400000d0u")] - public const uint KKpMemstore = 0x400000d0U; + [return: NativeTypeName("SDL_TimerID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AddTimer( + [NativeTypeName("Uint32")] uint interval, + [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + Ref userdata + ) => DllImport.AddTimer(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_MEMRECALL 0x400000d1u")] - public const uint KKpMemrecall = 0x400000d1U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[14] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[14] = nativeContext.LoadFunction("SDL_AddTimerNS", "SDL3") + ) + )(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_MEMCLEAR 0x400000d2u")] - public const uint KKpMemclear = 0x400000d2U; + [return: NativeTypeName("SDL_TimerID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + void* userdata + ) => DllImport.AddTimerNS(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_MEMADD 0x400000d3u")] - public const uint KKpMemadd = 0x400000d3U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (uint)((ISdl)this).AddTimerNS(interval, callback, __dsl_userdata); + } + } - [NativeTypeName("#define SDLK_KP_MEMSUBTRACT 0x400000d4u")] - public const uint KKpMemsubtract = 0x400000d4U; + [return: NativeTypeName("SDL_TimerID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AddTimerNS( + [NativeTypeName("Uint64")] ulong interval, + [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + Ref userdata + ) => DllImport.AddTimerNS(interval, callback, userdata); - [NativeTypeName("#define SDLK_KP_MEMMULTIPLY 0x400000d5u")] - public const uint KKpMemmultiply = 0x400000d5U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AddVulkanRenderSemaphores( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + (MaybeBool) + (byte) + ((ISdl)this).AddVulkanRenderSemaphoresRaw( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [NativeTypeName("#define SDLK_KP_MEMDIVIDE 0x400000d6u")] - public const uint KKpMemdivide = 0x400000d6U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AddVulkanRenderSemaphores( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + DllImport.AddVulkanRenderSemaphores( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [NativeTypeName("#define SDLK_KP_PLUSMINUS 0x400000d7u")] - public const uint KKpPlusminus = 0x400000d7U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AddVulkanRenderSemaphoresRaw( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + ( + (delegate* unmanaged)( + _slots[15] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[15] = nativeContext.LoadFunction( + "SDL_AddVulkanRenderSemaphores", + "SDL3" + ) + ) + )(renderer, wait_stage_mask, wait_semaphore, signal_semaphore); - [NativeTypeName("#define SDLK_KP_CLEAR 0x400000d8u")] - public const uint KKpClear = 0x400000d8U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AddVulkanRenderSemaphoresRaw( + RendererHandle renderer, + [NativeTypeName("Uint32")] uint wait_stage_mask, + [NativeTypeName("Sint64")] long wait_semaphore, + [NativeTypeName("Sint64")] long signal_semaphore + ) => + DllImport.AddVulkanRenderSemaphoresRaw( + renderer, + wait_stage_mask, + wait_semaphore, + signal_semaphore + ); - [NativeTypeName("#define SDLK_KP_CLEARENTRY 0x400000d9u")] - public const uint KKpClearentry = 0x400000d9U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => (void*)((ISdl)this).AlignedAllocRaw(alignment, size); - [NativeTypeName("#define SDLK_KP_BINARY 0x400000dau")] - public const uint KKpBinary = 0x400000daU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr AlignedAlloc( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => DllImport.AlignedAlloc(alignment, size); - [NativeTypeName("#define SDLK_KP_OCTAL 0x400000dbu")] - public const uint KKpOctal = 0x400000dbU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => + ( + (delegate* unmanaged)( + _slots[16] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[16] = nativeContext.LoadFunction("SDL_aligned_alloc", "SDL3") + ) + )(alignment, size); - [NativeTypeName("#define SDLK_KP_DECIMAL 0x400000dcu")] - public const uint KKpDecimal = 0x400000dcU; + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_alloc")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void* AlignedAllocRaw( + [NativeTypeName("size_t")] nuint alignment, + [NativeTypeName("size_t")] nuint size + ) => DllImport.AlignedAllocRaw(alignment, size); - [NativeTypeName("#define SDLK_KP_HEXADECIMAL 0x400000ddu")] - public const uint KKpHexadecimal = 0x400000ddU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.AlignedFree(void* mem) => + ( + (delegate* unmanaged)( + _slots[17] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[17] = nativeContext.LoadFunction("SDL_aligned_free", "SDL3") + ) + )(mem); - [NativeTypeName("#define SDLK_LCTRL 0x400000e0u")] - public const uint KLctrl = 0x400000e0U; + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void AlignedFree(void* mem) => DllImport.AlignedFree(mem); - [NativeTypeName("#define SDLK_LSHIFT 0x400000e1u")] - public const uint KLshift = 0x400000e1U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.AlignedFree(Ref mem) + { + fixed (void* __dsl_mem = mem) + { + ((ISdl)this).AlignedFree(__dsl_mem); + } + } - [NativeTypeName("#define SDLK_LALT 0x400000e2u")] - public const uint KLalt = 0x400000e2U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_aligned_free")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void AlignedFree(Ref mem) => DllImport.AlignedFree(mem); - [NativeTypeName("#define SDLK_LGUI 0x400000e3u")] - public const uint KLgui = 0x400000e3U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Asin(double x) => + ( + (delegate* unmanaged)( + _slots[18] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[18] = nativeContext.LoadFunction("SDL_asin", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_RCTRL 0x400000e4u")] - public const uint KRctrl = 0x400000e4U; + [NativeFunction("SDL3", EntryPoint = "SDL_asin")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Asin(double x) => DllImport.Asin(x); - [NativeTypeName("#define SDLK_RSHIFT 0x400000e5u")] - public const uint KRshift = 0x400000e5U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Asinf(float x) => + ( + (delegate* unmanaged)( + _slots[19] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[19] = nativeContext.LoadFunction("SDL_asinf", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_RALT 0x400000e6u")] - public const uint KRalt = 0x400000e6U; + [NativeFunction("SDL3", EntryPoint = "SDL_asinf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Asinf(float x) => DllImport.Asinf(x); - [NativeTypeName("#define SDLK_RGUI 0x400000e7u")] - public const uint KRgui = 0x400000e7U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Atan(double x) => + ( + (delegate* unmanaged)( + _slots[20] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[20] = nativeContext.LoadFunction("SDL_atan", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_MODE 0x40000101u")] - public const uint KMode = 0x40000101U; + [NativeFunction("SDL3", EntryPoint = "SDL_atan")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Atan(double x) => DllImport.Atan(x); - [NativeTypeName("#define SDLK_SLEEP 0x40000102u")] - public const uint KSleep = 0x40000102U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Atan2(double y, double x) => + ( + (delegate* unmanaged)( + _slots[21] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[21] = nativeContext.LoadFunction("SDL_atan2", "SDL3") + ) + )(y, x); - [NativeTypeName("#define SDLK_WAKE 0x40000103u")] - public const uint KWake = 0x40000103U; + [NativeFunction("SDL3", EntryPoint = "SDL_atan2")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Atan2(double y, double x) => DllImport.Atan2(y, x); - [NativeTypeName("#define SDLK_CHANNEL_INCREMENT 0x40000104u")] - public const uint KChannelIncrement = 0x40000104U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Atan2F(float y, float x) => + ( + (delegate* unmanaged)( + _slots[22] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[22] = nativeContext.LoadFunction("SDL_atan2f", "SDL3") + ) + )(y, x); - [NativeTypeName("#define SDLK_CHANNEL_DECREMENT 0x40000105u")] - public const uint KChannelDecrement = 0x40000105U; + [NativeFunction("SDL3", EntryPoint = "SDL_atan2f")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Atan2F(float y, float x) => DllImport.Atan2F(y, x); - [NativeTypeName("#define SDLK_MEDIA_PLAY 0x40000106u")] - public const uint KMediaPlay = 0x40000106U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Atanf(float x) => + ( + (delegate* unmanaged)( + _slots[23] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[23] = nativeContext.LoadFunction("SDL_atanf", "SDL3") + ) + )(x); - [NativeTypeName("#define SDLK_MEDIA_PAUSE 0x40000107u")] - public const uint KMediaPause = 0x40000107U; + [NativeFunction("SDL3", EntryPoint = "SDL_atanf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Atanf(float x) => DllImport.Atanf(x); - [NativeTypeName("#define SDLK_MEDIA_RECORD 0x40000108u")] - public const uint KMediaRecord = 0x40000108U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Atof([NativeTypeName("const char *")] sbyte* str) => + ( + (delegate* unmanaged)( + _slots[24] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[24] = nativeContext.LoadFunction("SDL_atof", "SDL3") + ) + )(str); - [NativeTypeName("#define SDLK_MEDIA_FAST_FORWARD 0x40000109u")] - public const uint KMediaFastForward = 0x40000109U; + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Atof([NativeTypeName("const char *")] sbyte* str) => DllImport.Atof(str); - [NativeTypeName("#define SDLK_MEDIA_REWIND 0x4000010au")] - public const uint KMediaRewind = 0x4000010aU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Atof([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (double)((ISdl)this).Atof(__dsl_str); + } + } - [NativeTypeName("#define SDLK_MEDIA_NEXT_TRACK 0x4000010bu")] - public const uint KMediaNextTrack = 0x4000010bU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atof")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Atof([NativeTypeName("const char *")] Ref str) => + DllImport.Atof(str); - [NativeTypeName("#define SDLK_MEDIA_PREVIOUS_TRACK 0x4000010cu")] - public const uint KMediaPreviousTrack = 0x4000010cU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Atoi([NativeTypeName("const char *")] sbyte* str) => + ( + (delegate* unmanaged)( + _slots[25] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[25] = nativeContext.LoadFunction("SDL_atoi", "SDL3") + ) + )(str); - [NativeTypeName("#define SDLK_MEDIA_STOP 0x4000010du")] - public const uint KMediaStop = 0x4000010dU; + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Atoi([NativeTypeName("const char *")] sbyte* str) => DllImport.Atoi(str); - [NativeTypeName("#define SDLK_MEDIA_EJECT 0x4000010eu")] - public const uint KMediaEject = 0x4000010eU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Atoi([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (int)((ISdl)this).Atoi(__dsl_str); + } + } - [NativeTypeName("#define SDLK_MEDIA_PLAY_PAUSE 0x4000010fu")] - public const uint KMediaPlayPause = 0x4000010fU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_atoi")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Atoi([NativeTypeName("const char *")] Ref str) => DllImport.Atoi(str); - [NativeTypeName("#define SDLK_MEDIA_SELECT 0x40000110u")] - public const uint KMediaSelect = 0x40000110U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + ) => + ( + (delegate* unmanaged)( + _slots[26] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[26] = nativeContext.LoadFunction("SDL_AttachVirtualJoystick", "SDL3") + ) + )(desc); - [NativeTypeName("#define SDLK_AC_NEW 0x40000111u")] - public const uint KAcNew = 0x40000111U; + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc + ) => DllImport.AttachVirtualJoystick(desc); - [NativeTypeName("#define SDLK_AC_OPEN 0x40000112u")] - public const uint KAcOpen = 0x40000112U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + ) + { + fixed (VirtualJoystickDesc* __dsl_desc = desc) + { + return (uint)((ISdl)this).AttachVirtualJoystick(__dsl_desc); + } + } - [NativeTypeName("#define SDLK_AC_CLOSE 0x40000113u")] - public const uint KAcClose = 0x40000113U; + [return: NativeTypeName("SDL_JoystickID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint AttachVirtualJoystick( + [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + ) => DllImport.AttachVirtualJoystick(desc); - [NativeTypeName("#define SDLK_AC_EXIT 0x40000114u")] - public const uint KAcExit = 0x40000114U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + (MaybeBool)(byte)((ISdl)this).AudioDevicePausedRaw(dev); - [NativeTypeName("#define SDLK_AC_SAVE 0x40000115u")] - public const uint KAcSave = 0x40000115U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool AudioDevicePaused( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => DllImport.AudioDevicePaused(dev); - [NativeTypeName("#define SDLK_AC_PRINT 0x40000116u")] - public const uint KAcPrint = 0x40000116U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + ( + (delegate* unmanaged)( + _slots[27] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[27] = nativeContext.LoadFunction("SDL_AudioDevicePaused", "SDL3") + ) + )(dev); - [NativeTypeName("#define SDLK_AC_PROPERTIES 0x40000117u")] - public const uint KAcProperties = 0x40000117U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + DllImport.AudioDevicePausedRaw(dev); - [NativeTypeName("#define SDLK_AC_SEARCH 0x40000118u")] - public const uint KAcSearch = 0x40000118U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUComputePassHandle ISdl.BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + ( + (delegate* unmanaged< + GPUCommandBufferHandle, + GPUStorageTextureReadWriteBinding*, + uint, + GPUStorageBufferReadWriteBinding*, + uint, + GPUComputePassHandle>)( + _slots[28] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[28] = nativeContext.LoadFunction("SDL_BeginGPUComputePass", "SDL3") + ) + )( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [NativeTypeName("#define SDLK_AC_HOME 0x40000119u")] - public const uint KAcHome = 0x40000119U; + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + GPUStorageTextureReadWriteBinding* storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + GPUStorageBufferReadWriteBinding* storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + DllImport.BeginGPUComputePass( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [NativeTypeName("#define SDLK_AC_BACK 0x4000011au")] - public const uint KAcBack = 0x4000011aU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUComputePassHandle ISdl.BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) + { + fixed ( + GPUStorageBufferReadWriteBinding* __dsl_storage_buffer_bindings = + storage_buffer_bindings + ) + fixed ( + GPUStorageTextureReadWriteBinding* __dsl_storage_texture_bindings = + storage_texture_bindings + ) + { + return (GPUComputePassHandle) + ((ISdl)this).BeginGPUComputePass( + command_buffer, + __dsl_storage_texture_bindings, + num_storage_texture_bindings, + __dsl_storage_buffer_bindings, + num_storage_buffer_bindings + ); + } + } - [NativeTypeName("#define SDLK_AC_FORWARD 0x4000011bu")] - public const uint KAcForward = 0x4000011bU; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUComputePass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUComputePassHandle BeginGPUComputePass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUStorageTextureReadWriteBinding *")] + Ref storage_texture_bindings, + [NativeTypeName("Uint32")] uint num_storage_texture_bindings, + [NativeTypeName("const SDL_GPUStorageBufferReadWriteBinding *")] + Ref storage_buffer_bindings, + [NativeTypeName("Uint32")] uint num_storage_buffer_bindings + ) => + DllImport.BeginGPUComputePass( + command_buffer, + storage_texture_bindings, + num_storage_texture_bindings, + storage_buffer_bindings, + num_storage_buffer_bindings + ); - [NativeTypeName("#define SDLK_AC_STOP 0x4000011cu")] - public const uint KAcStop = 0x4000011cU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUCopyPassHandle ISdl.BeginGPUCopyPass(GPUCommandBufferHandle command_buffer) => + ( + (delegate* unmanaged)( + _slots[29] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[29] = nativeContext.LoadFunction("SDL_BeginGPUCopyPass", "SDL3") + ) + )(command_buffer); - [NativeTypeName("#define SDLK_AC_REFRESH 0x4000011du")] - public const uint KAcRefresh = 0x4000011dU; + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPUCopyPass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUCopyPassHandle BeginGPUCopyPass(GPUCommandBufferHandle command_buffer) => + DllImport.BeginGPUCopyPass(command_buffer); - [NativeTypeName("#define SDLK_AC_BOOKMARKS 0x4000011eu")] - public const uint KAcBookmarks = 0x4000011eU; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPURenderPassHandle ISdl.BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ) => + ( + (delegate* unmanaged< + GPUCommandBufferHandle, + GPUColorTargetInfo*, + uint, + GPUDepthStencilTargetInfo*, + GPURenderPassHandle>)( + _slots[30] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[30] = nativeContext.LoadFunction("SDL_BeginGPURenderPass", "SDL3") + ) + )(command_buffer, color_target_infos, num_color_targets, depth_stencil_target_info); - [NativeTypeName("#define SDLK_SOFTLEFT 0x4000011fu")] - public const uint KSoftleft = 0x4000011fU; + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] GPUColorTargetInfo* color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + GPUDepthStencilTargetInfo* depth_stencil_target_info + ) => + DllImport.BeginGPURenderPass( + command_buffer, + color_target_infos, + num_color_targets, + depth_stencil_target_info + ); - [NativeTypeName("#define SDLK_SOFTRIGHT 0x40000120u")] - public const uint KSoftright = 0x40000120U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPURenderPassHandle ISdl.BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ) + { + fixed ( + GPUDepthStencilTargetInfo* __dsl_depth_stencil_target_info = depth_stencil_target_info + ) + fixed (GPUColorTargetInfo* __dsl_color_target_infos = color_target_infos) + { + return (GPURenderPassHandle) + ((ISdl)this).BeginGPURenderPass( + command_buffer, + __dsl_color_target_infos, + num_color_targets, + __dsl_depth_stencil_target_info + ); + } + } - [NativeTypeName("#define SDLK_CALL 0x40000121u")] - public const uint KCall = 0x40000121U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BeginGPURenderPass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPURenderPassHandle BeginGPURenderPass( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUColorTargetInfo *")] + Ref color_target_infos, + [NativeTypeName("Uint32")] uint num_color_targets, + [NativeTypeName("const SDL_GPUDepthStencilTargetInfo *")] + Ref depth_stencil_target_info + ) => + DllImport.BeginGPURenderPass( + command_buffer, + color_target_infos, + num_color_targets, + depth_stencil_target_info + ); - [NativeTypeName("#define SDLK_ENDCALL 0x40000122u")] - public const uint KEndcall = 0x40000122U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BindAudioStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => (MaybeBool)(byte)((ISdl)this).BindAudioStreamRaw(devid, stream); - [NativeTypeName("#define SDL_KMOD_NONE 0x0000u")] - public const uint KmodNone = 0x0000U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BindAudioStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => DllImport.BindAudioStream(devid, stream); - [NativeTypeName("#define SDL_KMOD_LSHIFT 0x0001u")] - public const uint KmodLshift = 0x0001U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BindAudioStreamRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => + ( + (delegate* unmanaged)( + _slots[31] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[31] = nativeContext.LoadFunction("SDL_BindAudioStream", "SDL3") + ) + )(devid, stream); - [NativeTypeName("#define SDL_KMOD_RSHIFT 0x0002u")] - public const uint KmodRshift = 0x0002U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BindAudioStreamRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle stream + ) => DllImport.BindAudioStreamRaw(devid, stream); - [NativeTypeName("#define SDL_KMOD_LCTRL 0x0040u")] - public const uint KmodLctrl = 0x0040U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle* streams, + int num_streams + ) => + ( + (delegate* unmanaged)( + _slots[32] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[32] = nativeContext.LoadFunction("SDL_BindAudioStreams", "SDL3") + ) + )(devid, streams, num_streams); - [NativeTypeName("#define SDL_KMOD_RCTRL 0x0080u")] - public const uint KmodRctrl = 0x0080U; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioStreamHandle* streams, + int num_streams + ) => DllImport.BindAudioStreams(devid, streams, num_streams); - [NativeTypeName("#define SDL_KMOD_LALT 0x0100u")] - public const uint KmodLalt = 0x0100U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref streams, + int num_streams + ) + { + fixed (AudioStreamHandle* __dsl_streams = streams) + { + return (MaybeBool) + (byte)((ISdl)this).BindAudioStreams(devid, __dsl_streams, num_streams); + } + } - [NativeTypeName("#define SDL_KMOD_RALT 0x0200u")] - public const uint KmodRalt = 0x0200U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BindAudioStreams( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref streams, + int num_streams + ) => DllImport.BindAudioStreams(devid, streams, num_streams); - [NativeTypeName("#define SDL_KMOD_LGUI 0x0400u")] - public const uint KmodLgui = 0x0400U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ) => + ( + (delegate* unmanaged)( + _slots[33] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[33] = nativeContext.LoadFunction("SDL_BindGPUComputePipeline", "SDL3") + ) + )(compute_pass, compute_pipeline); - [NativeTypeName("#define SDL_KMOD_RGUI 0x0800u")] - public const uint KmodRgui = 0x0800U; + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputePipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputePipeline( + GPUComputePassHandle compute_pass, + GPUComputePipelineHandle compute_pipeline + ) => DllImport.BindGPUComputePipeline(compute_pass, compute_pipeline); - [NativeTypeName("#define SDL_KMOD_NUM 0x1000u")] - public const uint KmodNum = 0x1000U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged< + GPUComputePassHandle, + uint, + GPUTextureSamplerBinding*, + uint, + void>)( + _slots[34] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[34] = nativeContext.LoadFunction("SDL_BindGPUComputeSamplers", "SDL3") + ) + )(compute_pass, first_slot, texture_sampler_bindings, num_bindings); - [NativeTypeName("#define SDL_KMOD_CAPS 0x2000u")] - public const uint KmodCaps = 0x2000U; + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeSamplers( + compute_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_KMOD_MODE 0x4000u")] - public const uint KmodMode = 0x4000U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings) + { + ((ISdl)this).BindGPUComputeSamplers( + compute_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_KMOD_SCROLL 0x8000u")] - public const uint KmodScroll = 0x8000U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeSamplers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeSamplers( + compute_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_KMOD_CTRL (SDL_KMOD_LCTRL | SDL_KMOD_RCTRL)")] - public const uint KmodCtrl = (0x0040U | 0x0080U); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[35] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[35] = nativeContext.LoadFunction( + "SDL_BindGPUComputeStorageBuffers", + "SDL3" + ) + ) + )(compute_pass, first_slot, storage_buffers, num_bindings); - [NativeTypeName("#define SDL_KMOD_SHIFT (SDL_KMOD_LSHIFT | SDL_KMOD_RSHIFT)")] - public const uint KmodShift = (0x0001U | 0x0002U); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_KMOD_ALT (SDL_KMOD_LALT | SDL_KMOD_RALT)")] - public const uint KmodAlt = (0x0100U | 0x0200U); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + ((ISdl)this).BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_KMOD_GUI (SDL_KMOD_LGUI | SDL_KMOD_RGUI)")] - public const uint KmodGui = (0x0400U | 0x0800U); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeStorageBuffers( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeStorageBuffers( + compute_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_PROP_TEXTINPUT_TYPE_NUMBER \"SDL.textinput.type\"")] - public static Utf8String PropTextinputTypeNumber => "SDL.textinput.type"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[36] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[36] = nativeContext.LoadFunction( + "SDL_BindGPUComputeStorageTextures", + "SDL3" + ) + ) + )(compute_pass, first_slot, storage_textures, num_bindings); - [NativeTypeName( - "#define SDL_PROP_TEXTINPUT_CAPITALIZATION_NUMBER \"SDL.textinput.capitalization\"" - )] - public static Utf8String PropTextinputCapitalizationNumber => "SDL.textinput.capitalization"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeStorageTextures( + compute_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName("#define SDL_PROP_TEXTINPUT_AUTOCORRECT_BOOLEAN \"SDL.textinput.autocorrect\"")] - public static Utf8String PropTextinputAutocorrectBoolean => "SDL.textinput.autocorrect"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + ((ISdl)this).BindGPUComputeStorageTextures( + compute_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_PROP_TEXTINPUT_MULTILINE_BOOLEAN \"SDL.textinput.multiline\"")] - public static Utf8String PropTextinputMultilineBoolean => "SDL.textinput.multiline"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUComputeStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUComputeStorageTextures( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUComputeStorageTextures( + compute_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName( - "#define SDL_PROP_TEXTINPUT_ANDROID_INPUTTYPE_NUMBER \"SDL.textinput.android.inputtype\"" - )] - public static Utf8String PropTextinputAndroidInputtypeNumber => - "SDL.textinput.android.inputtype"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[37] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[37] = nativeContext.LoadFunction("SDL_BindGPUFragmentSamplers", "SDL3") + ) + )(render_pass, first_slot, texture_sampler_bindings, num_bindings); - [NativeTypeName("#define SDL_BUTTON_LEFT 1")] - public const int ButtonLeft = 1; + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_BUTTON_MIDDLE 2")] - public const int ButtonMiddle = 2; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings) + { + ((ISdl)this).BindGPUFragmentSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_BUTTON_RIGHT 3")] - public const int ButtonRight = 3; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_BUTTON_X1 4")] - public const int ButtonX1 = 4; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[38] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[38] = nativeContext.LoadFunction( + "SDL_BindGPUFragmentStorageBuffers", + "SDL3" + ) + ) + )(render_pass, first_slot, storage_buffers, num_bindings); - [NativeTypeName("#define SDL_BUTTON_X2 5")] - public const int ButtonX2 = 5; + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_BUTTON_LMASK SDL_BUTTON_MASK(SDL_BUTTON_LEFT)")] - public const uint ButtonLmask = (1U << ((1) - 1)); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + ((ISdl)this).BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_BUTTON_MMASK SDL_BUTTON_MASK(SDL_BUTTON_MIDDLE)")] - public const uint ButtonMmask = (1U << ((2) - 1)); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_BUTTON_RMASK SDL_BUTTON_MASK(SDL_BUTTON_RIGHT)")] - public const uint ButtonRmask = (1U << ((3) - 1)); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[39] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[39] = nativeContext.LoadFunction( + "SDL_BindGPUFragmentStorageTextures", + "SDL3" + ) + ) + )(render_pass, first_slot, storage_textures, num_bindings); - [NativeTypeName("#define SDL_BUTTON_X1MASK SDL_BUTTON_MASK(SDL_BUTTON_X1)")] - public const uint ButtonX1Mask = (1U << ((4) - 1)); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName("#define SDL_BUTTON_X2MASK SDL_BUTTON_MASK(SDL_BUTTON_X2)")] - public const uint ButtonX2Mask = (1U << ((5) - 1)); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + ((ISdl)this).BindGPUFragmentStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_PEN_INPUT_DOWN (1u << 0)")] - public const uint PenInputDown = (1U << 0); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUFragmentStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUFragmentStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUFragmentStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_1 (1u << 1)")] - public const uint PenInputButton1 = (1U << 1); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ) => + ( + (delegate* unmanaged)( + _slots[40] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[40] = nativeContext.LoadFunction("SDL_BindGPUGraphicsPipeline", "SDL3") + ) + )(render_pass, graphics_pipeline); - [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_2 (1u << 2)")] - public const uint PenInputButton2 = (1U << 2); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUGraphicsPipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUGraphicsPipeline( + GPURenderPassHandle render_pass, + GPUGraphicsPipelineHandle graphics_pipeline + ) => DllImport.BindGPUGraphicsPipeline(render_pass, graphics_pipeline); - [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_3 (1u << 3)")] - public const uint PenInputButton3 = (1U << 3); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ) => + ( + (delegate* unmanaged< + GPURenderPassHandle, + GPUBufferBinding*, + GPUIndexElementSize, + void>)( + _slots[41] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[41] = nativeContext.LoadFunction("SDL_BindGPUIndexBuffer", "SDL3") + ) + )(render_pass, binding, index_element_size); - [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_4 (1u << 4)")] - public const uint PenInputButton4 = (1U << 4); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* binding, + GPUIndexElementSize index_element_size + ) => DllImport.BindGPUIndexBuffer(render_pass, binding, index_element_size); - [NativeTypeName("#define SDL_PEN_INPUT_BUTTON_5 (1u << 5)")] - public const uint PenInputButton5 = (1U << 5); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ) + { + fixed (GPUBufferBinding* __dsl_binding = binding) + { + ((ISdl)this).BindGPUIndexBuffer(render_pass, __dsl_binding, index_element_size); + } + } - [NativeTypeName("#define SDL_PEN_INPUT_ERASER_TIP (1u << 30)")] - public const uint PenInputEraserTip = (1U << 30); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUIndexBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUIndexBuffer( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref binding, + GPUIndexElementSize index_element_size + ) => DllImport.BindGPUIndexBuffer(render_pass, binding, index_element_size); - [NativeTypeName("#define SDL_TOUCH_MOUSEID ((SDL_MouseID)-1)")] - public const uint TouchMouseid = unchecked((uint)(-1)); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[42] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[42] = nativeContext.LoadFunction("SDL_BindGPUVertexBuffers", "SDL3") + ) + )(render_pass, first_slot, bindings, num_bindings); - [NativeTypeName("#define SDL_MOUSE_TOUCHID ((SDL_TouchID)-1)")] - public const ulong MouseTouchid = unchecked((ulong)(-1)); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] GPUBufferBinding* bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => DllImport.BindGPUVertexBuffers(render_pass, first_slot, bindings, num_bindings); - [NativeTypeName("#define SDL_GLOB_CASEINSENSITIVE (1u << 0)")] - public const uint GlobCaseinsensitive = (1U << 0); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferBinding* __dsl_bindings = bindings) + { + ((ISdl)this).BindGPUVertexBuffers( + render_pass, + first_slot, + __dsl_bindings, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_HAPTIC_CONSTANT (1u<<0)")] - public const uint HapticConstant = (1U << 0); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUBufferBinding *")] Ref bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => DllImport.BindGPUVertexBuffers(render_pass, first_slot, bindings, num_bindings); - [NativeTypeName("#define SDL_HAPTIC_SINE (1u<<1)")] - public const uint HapticSine = (1U << 1); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[43] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[43] = nativeContext.LoadFunction("SDL_BindGPUVertexSamplers", "SDL3") + ) + )(render_pass, first_slot, texture_sampler_bindings, num_bindings); - [NativeTypeName("#define SDL_HAPTIC_SQUARE (1u<<2)")] - public const uint HapticSquare = (1U << 2); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + GPUTextureSamplerBinding* texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_TRIANGLE (1u<<3)")] - public const uint HapticTriangle = (1U << 3); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureSamplerBinding* __dsl_texture_sampler_bindings = texture_sampler_bindings) + { + ((ISdl)this).BindGPUVertexSamplers( + render_pass, + first_slot, + __dsl_texture_sampler_bindings, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_HAPTIC_SAWTOOTHUP (1u<<4)")] - public const uint HapticSawtoothup = (1U << 4); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexSamplers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexSamplers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("const SDL_GPUTextureSamplerBinding *")] + Ref texture_sampler_bindings, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexSamplers( + render_pass, + first_slot, + texture_sampler_bindings, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_SAWTOOTHDOWN (1u<<5)")] - public const uint HapticSawtoothdown = (1U << 5); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[44] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[44] = nativeContext.LoadFunction( + "SDL_BindGPUVertexStorageBuffers", + "SDL3" + ) + ) + )(render_pass, first_slot, storage_buffers, num_bindings); - [NativeTypeName("#define SDL_HAPTIC_RAMP (1u<<6)")] - public const uint HapticRamp = (1U << 6); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] GPUBufferHandle* storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_SPRING (1u<<7)")] - public const uint HapticSpring = (1U << 7); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUBufferHandle* __dsl_storage_buffers = storage_buffers) + { + ((ISdl)this).BindGPUVertexStorageBuffers( + render_pass, + first_slot, + __dsl_storage_buffers, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_HAPTIC_DAMPER (1u<<8)")] - public const uint HapticDamper = (1U << 8); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageBuffers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexStorageBuffers( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUBuffer *const *")] Ref storage_buffers, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexStorageBuffers( + render_pass, + first_slot, + storage_buffers, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_INERTIA (1u<<9)")] - public const uint HapticInertia = (1U << 9); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + ( + (delegate* unmanaged)( + _slots[45] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[45] = nativeContext.LoadFunction( + "SDL_BindGPUVertexStorageTextures", + "SDL3" + ) + ) + )(render_pass, first_slot, storage_textures, num_bindings); - [NativeTypeName("#define SDL_HAPTIC_FRICTION (1u<<10)")] - public const uint HapticFriction = (1U << 10); + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] GPUTextureHandle* storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_LEFTRIGHT (1u<<11)")] - public const uint HapticLeftright = (1U << 11); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) + { + fixed (GPUTextureHandle* __dsl_storage_textures = storage_textures) + { + ((ISdl)this).BindGPUVertexStorageTextures( + render_pass, + first_slot, + __dsl_storage_textures, + num_bindings + ); + } + } - [NativeTypeName("#define SDL_HAPTIC_RESERVED1 (1u<<12)")] - public const uint HapticReserved1 = (1U << 12); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BindGPUVertexStorageTextures")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BindGPUVertexStorageTextures( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint first_slot, + [NativeTypeName("SDL_GPUTexture *const *")] Ref storage_textures, + [NativeTypeName("Uint32")] uint num_bindings + ) => + DllImport.BindGPUVertexStorageTextures( + render_pass, + first_slot, + storage_textures, + num_bindings + ); - [NativeTypeName("#define SDL_HAPTIC_RESERVED2 (1u<<13)")] - public const uint HapticReserved2 = (1U << 13); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ) => + ( + (delegate* unmanaged)( + _slots[46] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[46] = nativeContext.LoadFunction("SDL_BlitGPUTexture", "SDL3") + ) + )(command_buffer, info); - [NativeTypeName("#define SDL_HAPTIC_RESERVED3 (1u<<14)")] - public const uint HapticReserved3 = (1U << 14); + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] GPUBlitInfo* info + ) => DllImport.BlitGPUTexture(command_buffer, info); - [NativeTypeName("#define SDL_HAPTIC_CUSTOM (1u<<15)")] - public const uint HapticCustom = (1U << 15); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info + ) + { + fixed (GPUBlitInfo* __dsl_info = info) + { + ((ISdl)this).BlitGPUTexture(command_buffer, __dsl_info); + } + } - [NativeTypeName("#define SDL_HAPTIC_GAIN (1u<<16)")] - public const uint HapticGain = (1U << 16); + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BlitGPUTexture( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const SDL_GPUBlitInfo *")] Ref info + ) => DllImport.BlitGPUTexture(command_buffer, info); - [NativeTypeName("#define SDL_HAPTIC_AUTOCENTER (1u<<17)")] - public const uint HapticAutocenter = (1U << 17); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurface( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + ( + (delegate* unmanaged)( + _slots[47] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[47] = nativeContext.LoadFunction("SDL_BlitSurface", "SDL3") + ) + )(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HAPTIC_STATUS (1u<<18)")] - public const uint HapticStatus = (1U << 18); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurface( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => DllImport.BlitSurface(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HAPTIC_PAUSE (1u<<19)")] - public const uint HapticPause = (1U << 19); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurface( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte)((ISdl)this).BlitSurface(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); + } + } - [NativeTypeName("#define SDL_HAPTIC_POLAR 0")] - public const int HapticPolar = 0; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurface( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => DllImport.BlitSurface(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HAPTIC_CARTESIAN 1")] - public const int HapticCartesian = 1; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurface9Grid( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + ( + (delegate* unmanaged< + Surface*, + Rect*, + int, + int, + int, + int, + float, + ScaleMode, + Surface*, + Rect*, + byte>)( + _slots[48] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[48] = nativeContext.LoadFunction("SDL_BlitSurface9Grid", "SDL3") + ) + )( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect + ); - [NativeTypeName("#define SDL_HAPTIC_SPHERICAL 2")] - public const int HapticSpherical = 2; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurface9Grid( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + DllImport.BlitSurface9Grid( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect + ); - [NativeTypeName("#define SDL_HAPTIC_STEERING_AXIS 3")] - public const int HapticSteeringAxis = 3; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurface9Grid( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurface9Grid( + __dsl_src, + __dsl_srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + __dsl_dst, + __dsl_dstrect + ); + } + } - [NativeTypeName("#define SDL_HAPTIC_INFINITY 4294967295U")] - public const uint HapticInfinity = 4294967295U; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurface9Grid( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + int left_width, + int right_width, + int top_height, + int bottom_height, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => + DllImport.BlitSurface9Grid( + src, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + scaleMode, + dst, + dstrect + ); - [NativeTypeName( - "#define SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED \"SDL_ALLOW_ALT_TAB_WHILE_GRABBED\"" - )] - public static Utf8String HintAllowAltTabWhileGrabbed => "SDL_ALLOW_ALT_TAB_WHILE_GRABBED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurfaceScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => + ( + (delegate* unmanaged)( + _slots[49] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[49] = nativeContext.LoadFunction("SDL_BlitSurfaceScaled", "SDL3") + ) + )(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName( - "#define SDL_HINT_ANDROID_ALLOW_RECREATE_ACTIVITY \"SDL_ANDROID_ALLOW_RECREATE_ACTIVITY\"" - )] - public static Utf8String HintAndroidAllowRecreateActivity => - "SDL_ANDROID_ALLOW_RECREATE_ACTIVITY"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurfaceScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => DllImport.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName("#define SDL_HINT_ANDROID_BLOCK_ON_PAUSE \"SDL_ANDROID_BLOCK_ON_PAUSE\"")] - public static Utf8String HintAndroidBlockOnPause => "SDL_ANDROID_BLOCK_ON_PAUSE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurfaceScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurfaceScaled( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect, + scaleMode + ); + } + } - [NativeTypeName("#define SDL_HINT_ANDROID_TRAP_BACK_BUTTON \"SDL_ANDROID_TRAP_BACK_BUTTON\"")] - public static Utf8String HintAndroidTrapBackButton => "SDL_ANDROID_TRAP_BACK_BUTTON"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurfaceScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) => DllImport.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName("#define SDL_HINT_APP_ID \"SDL_APP_ID\"")] - public static Utf8String HintAppId => "SDL_APP_ID"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurfaceTiled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + ( + (delegate* unmanaged)( + _slots[50] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[50] = nativeContext.LoadFunction("SDL_BlitSurfaceTiled", "SDL3") + ) + )(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HINT_APP_NAME \"SDL_APP_NAME\"")] - public static Utf8String HintAppName => "SDL_APP_NAME"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurfaceTiled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => DllImport.BlitSurfaceTiled(src, srcrect, dst, dstrect); - [NativeTypeName( - "#define SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS \"SDL_APPLE_TV_CONTROLLER_UI_EVENTS\"" - )] - public static Utf8String HintAppleTvControllerUiEvents => "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurfaceTiled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurfaceTiled( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect + ); + } + } - [NativeTypeName( - "#define SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION \"SDL_APPLE_TV_REMOTE_ALLOW_ROTATION\"" - )] - public static Utf8String HintAppleTvRemoteAllowRotation => - "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurfaceTiled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => DllImport.BlitSurfaceTiled(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_ALSA_DEFAULT_DEVICE \"SDL_AUDIO_ALSA_DEFAULT_DEVICE\"")] - public static Utf8String HintAudioAlsaDefaultDevice => "SDL_AUDIO_ALSA_DEFAULT_DEVICE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurfaceTiledWithScale( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + ( + (delegate* unmanaged)( + _slots[51] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[51] = nativeContext.LoadFunction( + "SDL_BlitSurfaceTiledWithScale", + "SDL3" + ) + ) + )(src, srcrect, scale, scaleMode, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_CATEGORY \"SDL_AUDIO_CATEGORY\"")] - public static Utf8String HintAudioCategory => "SDL_AUDIO_CATEGORY"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurfaceTiledWithScale( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + float scale, + ScaleMode scaleMode, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => DllImport.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_CHANNELS \"SDL_AUDIO_CHANNELS\"")] - public static Utf8String HintAudioChannels => "SDL_AUDIO_CHANNELS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurfaceTiledWithScale( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurfaceTiledWithScale( + __dsl_src, + __dsl_srcrect, + scale, + scaleMode, + __dsl_dst, + __dsl_dstrect + ); + } + } - [NativeTypeName( - "#define SDL_HINT_AUDIO_DEVICE_APP_ICON_NAME \"SDL_AUDIO_DEVICE_APP_ICON_NAME\"" - )] - public static Utf8String HintAudioDeviceAppIconName => "SDL_AUDIO_DEVICE_APP_ICON_NAME"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurfaceTiledWithScale( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + float scale, + ScaleMode scaleMode, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => DllImport.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); - [NativeTypeName( - "#define SDL_HINT_AUDIO_DEVICE_SAMPLE_FRAMES \"SDL_AUDIO_DEVICE_SAMPLE_FRAMES\"" - )] - public static Utf8String HintAudioDeviceSampleFrames => "SDL_AUDIO_DEVICE_SAMPLE_FRAMES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurfaceUnchecked( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => + ( + (delegate* unmanaged)( + _slots[52] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[52] = nativeContext.LoadFunction("SDL_BlitSurfaceUnchecked", "SDL3") + ) + )(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_DEVICE_STREAM_NAME \"SDL_AUDIO_DEVICE_STREAM_NAME\"")] - public static Utf8String HintAudioDeviceStreamName => "SDL_AUDIO_DEVICE_STREAM_NAME"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurfaceUnchecked( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect + ) => DllImport.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_DEVICE_STREAM_ROLE \"SDL_AUDIO_DEVICE_STREAM_ROLE\"")] - public static Utf8String HintAudioDeviceStreamRole => "SDL_AUDIO_DEVICE_STREAM_ROLE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurfaceUnchecked( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurfaceUnchecked( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect + ); + } + } - [NativeTypeName("#define SDL_HINT_AUDIO_DISK_INPUT_FILE \"SDL_AUDIO_DISK_INPUT_FILE\"")] - public static Utf8String HintAudioDiskInputFile => "SDL_AUDIO_DISK_INPUT_FILE"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurfaceUnchecked( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect + ) => DllImport.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); - [NativeTypeName("#define SDL_HINT_AUDIO_DISK_OUTPUT_FILE \"SDL_AUDIO_DISK_OUTPUT_FILE\"")] - public static Utf8String HintAudioDiskOutputFile => "SDL_AUDIO_DISK_OUTPUT_FILE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.BlitSurfaceUncheckedScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => + ( + (delegate* unmanaged)( + _slots[53] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[53] = nativeContext.LoadFunction( + "SDL_BlitSurfaceUncheckedScaled", + "SDL3" + ) + ) + )(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName("#define SDL_HINT_AUDIO_DISK_TIMESCALE \"SDL_AUDIO_DISK_TIMESCALE\"")] - public static Utf8String HintAudioDiskTimescale => "SDL_AUDIO_DISK_TIMESCALE"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte BlitSurfaceUncheckedScaled( + Surface* src, + [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* dstrect, + ScaleMode scaleMode + ) => DllImport.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName("#define SDL_HINT_AUDIO_DRIVER \"SDL_AUDIO_DRIVER\"")] - public static Utf8String HintAudioDriver => "SDL_AUDIO_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.BlitSurfaceUncheckedScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) + { + fixed (Rect* __dsl_dstrect = dstrect) + fixed (Surface* __dsl_dst = dst) + fixed (Rect* __dsl_srcrect = srcrect) + fixed (Surface* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).BlitSurfaceUncheckedScaled( + __dsl_src, + __dsl_srcrect, + __dsl_dst, + __dsl_dstrect, + scaleMode + ); + } + } - [NativeTypeName("#define SDL_HINT_AUDIO_DUMMY_TIMESCALE \"SDL_AUDIO_DUMMY_TIMESCALE\"")] - public static Utf8String HintAudioDummyTimescale => "SDL_AUDIO_DUMMY_TIMESCALE"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool BlitSurfaceUncheckedScaled( + Ref src, + [NativeTypeName("const SDL_Rect *")] Ref srcrect, + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref dstrect, + ScaleMode scaleMode + ) => DllImport.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); - [NativeTypeName("#define SDL_HINT_AUDIO_FORMAT \"SDL_AUDIO_FORMAT\"")] - public static Utf8String HintAudioFormat => "SDL_AUDIO_FORMAT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.BroadcastCondition(ConditionHandle cond) => + ( + (delegate* unmanaged)( + _slots[54] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[54] = nativeContext.LoadFunction("SDL_BroadcastCondition", "SDL3") + ) + )(cond); - [NativeTypeName("#define SDL_HINT_AUDIO_FREQUENCY \"SDL_AUDIO_FREQUENCY\"")] - public static Utf8String HintAudioFrequency => "SDL_AUDIO_FREQUENCY"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void BroadcastCondition(ConditionHandle cond) => + DllImport.BroadcastCondition(cond); - [NativeTypeName("#define SDL_HINT_AUDIO_INCLUDE_MONITORS \"SDL_AUDIO_INCLUDE_MONITORS\"")] - public static Utf8String HintAudioIncludeMonitors => "SDL_AUDIO_INCLUDE_MONITORS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => + ( + (delegate* unmanaged)( + _slots[55] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[55] = nativeContext.LoadFunction("SDL_bsearch", "SDL3") + ) + )(key, @base, nmemb, size, compare); - [NativeTypeName("#define SDL_HINT_AUTO_UPDATE_JOYSTICKS \"SDL_AUTO_UPDATE_JOYSTICKS\"")] - public static Utf8String HintAutoUpdateJoysticks => "SDL_AUTO_UPDATE_JOYSTICKS"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void* Bsearch( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => DllImport.Bsearch(key, @base, nmemb, size, compare); - [NativeTypeName("#define SDL_HINT_AUTO_UPDATE_SENSORS \"SDL_AUTO_UPDATE_SENSORS\"")] - public static Utf8String HintAutoUpdateSensors => "SDL_AUTO_UPDATE_SENSORS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) + { + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) + { + return (void*)((ISdl)this).Bsearch(__dsl_key, __dsl_base, nmemb, size, compare); + } + } - [NativeTypeName("#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT \"SDL_BMP_SAVE_LEGACY_FORMAT\"")] - public static Utf8String HintBmpSaveLegacyFormat => "SDL_BMP_SAVE_LEGACY_FORMAT"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Bsearch( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => DllImport.Bsearch(key, @base, nmemb, size, compare); - [NativeTypeName("#define SDL_HINT_CAMERA_DRIVER \"SDL_CAMERA_DRIVER\"")] - public static Utf8String HintCameraDriver => "SDL_CAMERA_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[56] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[56] = nativeContext.LoadFunction("SDL_bsearch_r", "SDL3") + ) + )(key, @base, nmemb, size, compare, userdata); - [NativeTypeName("#define SDL_HINT_CPU_FEATURE_MASK \"SDL_CPU_FEATURE_MASK\"")] - public static Utf8String HintCpuFeatureMask => "SDL_CPU_FEATURE_MASK"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void* BsearchR( + [NativeTypeName("const void *")] void* key, + [NativeTypeName("const void *")] void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => DllImport.BsearchR(key, @base, nmemb, size, compare, userdata); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) + fixed (void* __dsl_key = key) + { + return (void*) + ((ISdl)this).BsearchR(__dsl_key, __dsl_base, nmemb, size, compare, __dsl_userdata); + } + } - [NativeTypeName("#define SDL_HINT_JOYSTICK_DIRECTINPUT \"SDL_JOYSTICK_DIRECTINPUT\"")] - public static Utf8String HintJoystickDirectinput => "SDL_JOYSTICK_DIRECTINPUT"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_bsearch_r")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr BsearchR( + [NativeTypeName("const void *")] Ref key, + [NativeTypeName("const void *")] Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) => DllImport.BsearchR(key, @base, nmemb, size, compare, userdata); - [NativeTypeName("#define SDL_HINT_FILE_DIALOG_DRIVER \"SDL_FILE_DIALOG_DRIVER\"")] - public static Utf8String HintFileDialogDriver => "SDL_FILE_DIALOG_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ) => + ( + (delegate* unmanaged)( + _slots[57] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[57] = nativeContext.LoadFunction( + "SDL_CalculateGPUTextureFormatSize", + "SDL3" + ) + ) + )(format, width, height, depth_or_layer_count); - [NativeTypeName("#define SDL_HINT_DISPLAY_USABLE_BOUNDS \"SDL_DISPLAY_USABLE_BOUNDS\"")] - public static Utf8String HintDisplayUsableBounds => "SDL_DISPLAY_USABLE_BOUNDS"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_CalculateGPUTextureFormatSize")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint CalculateGPUTextureFormatSize( + GPUTextureFormat format, + [NativeTypeName("Uint32")] uint width, + [NativeTypeName("Uint32")] uint height, + [NativeTypeName("Uint32")] uint depth_or_layer_count + ) => DllImport.CalculateGPUTextureFormatSize(format, width, height, depth_or_layer_count); - [NativeTypeName("#define SDL_HINT_EMSCRIPTEN_ASYNCIFY \"SDL_EMSCRIPTEN_ASYNCIFY\"")] - public static Utf8String HintEmscriptenAsyncify => "SDL_EMSCRIPTEN_ASYNCIFY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => (void*)((ISdl)this).CallocRaw(nmemb, size); - [NativeTypeName( - "#define SDL_HINT_EMSCRIPTEN_CANVAS_SELECTOR \"SDL_EMSCRIPTEN_CANVAS_SELECTOR\"" - )] - public static Utf8String HintEmscriptenCanvasSelector => "SDL_EMSCRIPTEN_CANVAS_SELECTOR"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Calloc( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => DllImport.Calloc(nmemb, size); - [NativeTypeName( - "#define SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT \"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\"" - )] - public static Utf8String HintEmscriptenKeyboardElement => "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => + ( + (delegate* unmanaged)( + _slots[58] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[58] = nativeContext.LoadFunction("SDL_calloc", "SDL3") + ) + )(nmemb, size); - [NativeTypeName("#define SDL_HINT_ENABLE_SCREEN_KEYBOARD \"SDL_ENABLE_SCREEN_KEYBOARD\"")] - public static Utf8String HintEnableScreenKeyboard => "SDL_ENABLE_SCREEN_KEYBOARD"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_calloc")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void* CallocRaw( + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size + ) => DllImport.CallocRaw(nmemb, size); - [NativeTypeName("#define SDL_HINT_EVDEV_DEVICES \"SDL_EVDEV_DEVICES\"")] - public static Utf8String HintEvdevDevices => "SDL_EVDEV_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CancelGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + (MaybeBool)(byte)((ISdl)this).CancelGPUCommandBufferRaw(command_buffer); - [NativeTypeName("#define SDL_HINT_EVENT_LOGGING \"SDL_EVENT_LOGGING\"")] - public static Utf8String HintEventLogging => "SDL_EVENT_LOGGING"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CancelGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + DllImport.CancelGPUCommandBuffer(command_buffer); - [NativeTypeName("#define SDL_HINT_FORCE_RAISEWINDOW \"SDL_FORCE_RAISEWINDOW\"")] - public static Utf8String HintForceRaisewindow => "SDL_FORCE_RAISEWINDOW"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + ( + (delegate* unmanaged)( + _slots[59] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[59] = nativeContext.LoadFunction("SDL_CancelGPUCommandBuffer", "SDL3") + ) + )(command_buffer); - [NativeTypeName("#define SDL_HINT_FRAMEBUFFER_ACCELERATION \"SDL_FRAMEBUFFER_ACCELERATION\"")] - public static Utf8String HintFramebufferAcceleration => "SDL_FRAMEBUFFER_ACCELERATION"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CancelGPUCommandBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CancelGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + DllImport.CancelGPUCommandBufferRaw(command_buffer); - [NativeTypeName("#define SDL_HINT_GAMECONTROLLERCONFIG \"SDL_GAMECONTROLLERCONFIG\"")] - public static Utf8String HintGamecontrollerconfig => "SDL_GAMECONTROLLERCONFIG"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CaptureMouse([NativeTypeName("bool")] byte enabled) => + ( + (delegate* unmanaged)( + _slots[60] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[60] = nativeContext.LoadFunction("SDL_CaptureMouse", "SDL3") + ) + )(enabled); - [NativeTypeName("#define SDL_HINT_GAMECONTROLLERCONFIG_FILE \"SDL_GAMECONTROLLERCONFIG_FILE\"")] - public static Utf8String HintGamecontrollerconfigFile => "SDL_GAMECONTROLLERCONFIG_FILE"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CaptureMouse([NativeTypeName("bool")] byte enabled) => + DllImport.CaptureMouse(enabled); - [NativeTypeName("#define SDL_HINT_GAMECONTROLLERTYPE \"SDL_GAMECONTROLLERTYPE\"")] - public static Utf8String HintGamecontrollertype => "SDL_GAMECONTROLLERTYPE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => + (MaybeBool)(byte)((ISdl)this).CaptureMouse((byte)enabled); - [NativeTypeName( - "#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES \"SDL_GAMECONTROLLER_IGNORE_DEVICES\"" - )] - public static Utf8String HintGamecontrollerIgnoreDevices => - "SDL_GAMECONTROLLER_IGNORE_DEVICES"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => + DllImport.CaptureMouse(enabled); - [NativeTypeName( - "#define SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT \"SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT\"" - )] - public static Utf8String HintGamecontrollerIgnoreDevicesExcept => - "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Ceil(double x) => + ( + (delegate* unmanaged)( + _slots[61] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[61] = nativeContext.LoadFunction("SDL_ceil", "SDL3") + ) + )(x); - [NativeTypeName( - "#define SDL_HINT_GAMECONTROLLER_SENSOR_FUSION \"SDL_GAMECONTROLLER_SENSOR_FUSION\"" - )] - public static Utf8String HintGamecontrollerSensorFusion => "SDL_GAMECONTROLLER_SENSOR_FUSION"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_ceil")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Ceil(double x) => DllImport.Ceil(x); - [NativeTypeName( - "#define SDL_HINT_GDK_TEXTINPUT_DEFAULT_TEXT \"SDL_GDK_TEXTINPUT_DEFAULT_TEXT\"" - )] - public static Utf8String HintGdkTextinputDefaultText => "SDL_GDK_TEXTINPUT_DEFAULT_TEXT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Ceilf(float x) => + ( + (delegate* unmanaged)( + _slots[62] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[62] = nativeContext.LoadFunction("SDL_ceilf", "SDL3") + ) + )(x); - [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_DESCRIPTION \"SDL_GDK_TEXTINPUT_DESCRIPTION\"")] - public static Utf8String HintGdkTextinputDescription => "SDL_GDK_TEXTINPUT_DESCRIPTION"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_ceilf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Ceilf(float x) => DllImport.Ceilf(x); - [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_MAX_LENGTH \"SDL_GDK_TEXTINPUT_MAX_LENGTH\"")] - public static Utf8String HintGdkTextinputMaxLength => "SDL_GDK_TEXTINPUT_MAX_LENGTH"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClaimWindowForGPUDevice(GPUDeviceHandle device, WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).ClaimWindowForGPUDeviceRaw(device, window); - [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_SCOPE \"SDL_GDK_TEXTINPUT_SCOPE\"")] - public static Utf8String HintGdkTextinputScope => "SDL_GDK_TEXTINPUT_SCOPE"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClaimWindowForGPUDevice( + GPUDeviceHandle device, + WindowHandle window + ) => DllImport.ClaimWindowForGPUDevice(device, window); - [NativeTypeName("#define SDL_HINT_GDK_TEXTINPUT_TITLE \"SDL_GDK_TEXTINPUT_TITLE\"")] - public static Utf8String HintGdkTextinputTitle => "SDL_GDK_TEXTINPUT_TITLE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClaimWindowForGPUDeviceRaw(GPUDeviceHandle device, WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[63] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[63] = nativeContext.LoadFunction("SDL_ClaimWindowForGPUDevice", "SDL3") + ) + )(device, window); - [NativeTypeName("#define SDL_HINT_HIDAPI_LIBUSB \"SDL_HIDAPI_LIBUSB\"")] - public static Utf8String HintHidapiLibusb => "SDL_HIDAPI_LIBUSB"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClaimWindowForGPUDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClaimWindowForGPUDeviceRaw(GPUDeviceHandle device, WindowHandle window) => + DllImport.ClaimWindowForGPUDeviceRaw(device, window); - [NativeTypeName("#define SDL_HINT_HIDAPI_LIBUSB_WHITELIST \"SDL_HIDAPI_LIBUSB_WHITELIST\"")] - public static Utf8String HintHidapiLibusbWhitelist => "SDL_HIDAPI_LIBUSB_WHITELIST"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CleanupTLS() => + ( + (delegate* unmanaged)( + _slots[64] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[64] = nativeContext.LoadFunction("SDL_CleanupTLS", "SDL3") + ) + )(); - [NativeTypeName("#define SDL_HINT_HIDAPI_UDEV \"SDL_HIDAPI_UDEV\"")] - public static Utf8String HintHidapiUdev => "SDL_HIDAPI_UDEV"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CleanupTLS() => DllImport.CleanupTLS(); - [NativeTypeName("#define SDL_HINT_GPU_DRIVER \"SDL_GPU_DRIVER\"")] - public static Utf8String HintGpuDriver => "SDL_GPU_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearAudioStream(AudioStreamHandle stream) => + (MaybeBool)(byte)((ISdl)this).ClearAudioStreamRaw(stream); - [NativeTypeName( - "#define SDL_HINT_HIDAPI_ENUMERATE_ONLY_CONTROLLERS \"SDL_HIDAPI_ENUMERATE_ONLY_CONTROLLERS\"" - )] - public static Utf8String HintHidapiEnumerateOnlyControllers => - "SDL_HIDAPI_ENUMERATE_ONLY_CONTROLLERS"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearAudioStream(AudioStreamHandle stream) => + DllImport.ClearAudioStream(stream); - [NativeTypeName("#define SDL_HINT_HIDAPI_IGNORE_DEVICES \"SDL_HIDAPI_IGNORE_DEVICES\"")] - public static Utf8String HintHidapiIgnoreDevices => "SDL_HIDAPI_IGNORE_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearAudioStreamRaw(AudioStreamHandle stream) => + ( + (delegate* unmanaged)( + _slots[65] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[65] = nativeContext.LoadFunction("SDL_ClearAudioStream", "SDL3") + ) + )(stream); - [NativeTypeName("#define SDL_HINT_IME_IMPLEMENTED_UI \"SDL_IME_IMPLEMENTED_UI\"")] - public static Utf8String HintImeImplementedUi => "SDL_IME_IMPLEMENTED_UI"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearAudioStreamRaw(AudioStreamHandle stream) => + DllImport.ClearAudioStreamRaw(stream); - [NativeTypeName("#define SDL_HINT_IOS_HIDE_HOME_INDICATOR \"SDL_IOS_HIDE_HOME_INDICATOR\"")] - public static Utf8String HintIosHideHomeIndicator => "SDL_IOS_HIDE_HOME_INDICATOR"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearClipboardData() => + (MaybeBool)(byte)((ISdl)this).ClearClipboardDataRaw(); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS \"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS\"" - )] - public static Utf8String HintJoystickAllowBackgroundEvents => - "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearClipboardData() => DllImport.ClearClipboardData(); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES \"SDL_JOYSTICK_ARCADESTICK_DEVICES\"" - )] - public static Utf8String HintJoystickArcadestickDevices => "SDL_JOYSTICK_ARCADESTICK_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearClipboardDataRaw() => + ( + (delegate* unmanaged)( + _slots[66] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[66] = nativeContext.LoadFunction("SDL_ClearClipboardData", "SDL3") + ) + )(); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED \"SDL_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickArcadestickDevicesExcluded => - "SDL_JOYSTICK_ARCADESTICK_DEVICES_EXCLUDED"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearClipboardDataRaw() => DllImport.ClearClipboardDataRaw(); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES \"SDL_JOYSTICK_BLACKLIST_DEVICES\"" - )] - public static Utf8String HintJoystickBlacklistDevices => "SDL_JOYSTICK_BLACKLIST_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearComposition(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).ClearCompositionRaw(window); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED \"SDL_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickBlacklistDevicesExcluded => - "SDL_JOYSTICK_BLACKLIST_DEVICES_EXCLUDED"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearComposition(WindowHandle window) => + DllImport.ClearComposition(window); - [NativeTypeName("#define SDL_HINT_JOYSTICK_DEVICE \"SDL_JOYSTICK_DEVICE\"")] - public static Utf8String HintJoystickDevice => "SDL_JOYSTICK_DEVICE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearCompositionRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[67] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[67] = nativeContext.LoadFunction("SDL_ClearComposition", "SDL3") + ) + )(window); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES \"SDL_JOYSTICK_FLIGHTSTICK_DEVICES\"" - )] - public static Utf8String HintJoystickFlightstickDevices => "SDL_JOYSTICK_FLIGHTSTICK_DEVICES"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearCompositionRaw(WindowHandle window) => + DllImport.ClearCompositionRaw(window); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED \"SDL_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickFlightstickDevicesExcluded => - "SDL_JOYSTICK_FLIGHTSTICK_DEVICES_EXCLUDED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearError() => (MaybeBool)(byte)((ISdl)this).ClearErrorRaw(); - [NativeTypeName("#define SDL_HINT_JOYSTICK_GAMEINPUT \"SDL_JOYSTICK_GAMEINPUT\"")] - public static Utf8String HintJoystickGameinput => "SDL_JOYSTICK_GAMEINPUT"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearError() => DllImport.ClearError(); - [NativeTypeName("#define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES \"SDL_JOYSTICK_GAMECUBE_DEVICES\"")] - public static Utf8String HintJoystickGamecubeDevices => "SDL_JOYSTICK_GAMECUBE_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearErrorRaw() => + ( + (delegate* unmanaged)( + _slots[68] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[68] = nativeContext.LoadFunction("SDL_ClearError", "SDL3") + ) + )(); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED \"SDL_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickGamecubeDevicesExcluded => - "SDL_JOYSTICK_GAMECUBE_DEVICES_EXCLUDED"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearErrorRaw() => DllImport.ClearErrorRaw(); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI \"SDL_JOYSTICK_HIDAPI\"")] - public static Utf8String HintJoystickHidapi => "SDL_JOYSTICK_HIDAPI"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => + ( + (delegate* unmanaged)( + _slots[69] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[69] = nativeContext.LoadFunction("SDL_ClearProperty", "SDL3") + ) + )(props, name); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS \"SDL_JOYSTICK_HIDAPI_COMBINE_JOY_CONS\"" - )] - public static Utf8String HintJoystickHidapiCombineJoyCons => - "SDL_JOYSTICK_HIDAPI_COMBINE_JOY_CONS"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.ClearProperty(props, name); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE \"SDL_JOYSTICK_HIDAPI_GAMECUBE\"")] - public static Utf8String HintJoystickHidapiGamecube => "SDL_JOYSTICK_HIDAPI_GAMECUBE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)((ISdl)this).ClearProperty(props, __dsl_name); + } + } - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE \"SDL_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE\"" - )] - public static Utf8String HintJoystickHidapiGamecubeRumbleBrake => - "SDL_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => DllImport.ClearProperty(props, name); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS \"SDL_JOYSTICK_HIDAPI_JOY_CONS\"")] - public static Utf8String HintJoystickHidapiJoyCons => "SDL_JOYSTICK_HIDAPI_JOY_CONS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ClearSurface(Surface* surface, float r, float g, float b, float a) => + ( + (delegate* unmanaged)( + _slots[70] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[70] = nativeContext.LoadFunction("SDL_ClearSurface", "SDL3") + ) + )(surface, r, g, b, a); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED \"SDL_JOYSTICK_HIDAPI_JOYCON_HOME_LED\"" - )] - public static Utf8String HintJoystickHidapiJoyconHomeLed => - "SDL_JOYSTICK_HIDAPI_JOYCON_HOME_LED"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ClearSurface(Surface* surface, float r, float g, float b, float a) => + DllImport.ClearSurface(surface, r, g, b, a); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_LUNA \"SDL_JOYSTICK_HIDAPI_LUNA\"")] - public static Utf8String HintJoystickHidapiLuna => "SDL_JOYSTICK_HIDAPI_LUNA"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ClearSurface(Ref surface, float r, float g, float b, float a) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)((ISdl)this).ClearSurface(__dsl_surface, r, g, b, a); + } + } - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC \"SDL_JOYSTICK_HIDAPI_NINTENDO_CLASSIC\"" - )] - public static Utf8String HintJoystickHidapiNintendoClassic => - "SDL_JOYSTICK_HIDAPI_NINTENDO_CLASSIC"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ClearSurface( + Ref surface, + float r, + float g, + float b, + float a + ) => DllImport.ClearSurface(surface, r, g, b, a); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS3 \"SDL_JOYSTICK_HIDAPI_PS3\"")] - public static Utf8String HintJoystickHidapiPs3 => "SDL_JOYSTICK_HIDAPI_PS3"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + ( + (delegate* unmanaged)( + _slots[71] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[71] = nativeContext.LoadFunction("SDL_CloseAudioDevice", "SDL3") + ) + )(devid); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER \"SDL_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER\"" - )] - public static Utf8String HintJoystickHidapiPs3SixaxisDriver => - "SDL_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + DllImport.CloseAudioDevice(devid); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS4 \"SDL_JOYSTICK_HIDAPI_PS4\"")] - public static Utf8String HintJoystickHidapiPs4 => "SDL_JOYSTICK_HIDAPI_PS4"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseCamera(CameraHandle camera) => + ( + (delegate* unmanaged)( + _slots[72] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[72] = nativeContext.LoadFunction("SDL_CloseCamera", "SDL3") + ) + )(camera); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL \"SDL_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL\"" - )] - public static Utf8String HintJoystickHidapiPs4ReportInterval => - "SDL_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseCamera(CameraHandle camera) => DllImport.CloseCamera(camera); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE \"SDL_JOYSTICK_HIDAPI_PS4_RUMBLE\"" - )] - public static Utf8String HintJoystickHidapiPs4Rumble => "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseGamepad(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[73] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[73] = nativeContext.LoadFunction("SDL_CloseGamepad", "SDL3") + ) + )(gamepad); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_PS5 \"SDL_JOYSTICK_HIDAPI_PS5\"")] - public static Utf8String HintJoystickHidapiPs5 => "SDL_JOYSTICK_HIDAPI_PS5"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseGamepad(GamepadHandle gamepad) => DllImport.CloseGamepad(gamepad); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED\"" - )] - public static Utf8String HintJoystickHidapiPs5PlayerLed => - "SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseHaptic(HapticHandle haptic) => + ( + (delegate* unmanaged)( + _slots[74] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[74] = nativeContext.LoadFunction("SDL_CloseHaptic", "SDL3") + ) + )(haptic); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE \"SDL_JOYSTICK_HIDAPI_PS5_RUMBLE\"" - )] - public static Utf8String HintJoystickHidapiPs5Rumble => "SDL_JOYSTICK_HIDAPI_PS5_RUMBLE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseHaptic(HapticHandle haptic) => DllImport.CloseHaptic(haptic); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_SHIELD \"SDL_JOYSTICK_HIDAPI_SHIELD\"")] - public static Utf8String HintJoystickHidapiShield => "SDL_JOYSTICK_HIDAPI_SHIELD"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CloseIO(IOStreamHandle context) => + (MaybeBool)(byte)((ISdl)this).CloseIORaw(context); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STADIA \"SDL_JOYSTICK_HIDAPI_STADIA\"")] - public static Utf8String HintJoystickHidapiStadia => "SDL_JOYSTICK_HIDAPI_STADIA"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CloseIO(IOStreamHandle context) => DllImport.CloseIO(context); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STEAM \"SDL_JOYSTICK_HIDAPI_STEAM\"")] - public static Utf8String HintJoystickHidapiSteam => "SDL_JOYSTICK_HIDAPI_STEAM"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CloseIORaw(IOStreamHandle context) => + ( + (delegate* unmanaged)( + _slots[75] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[75] = nativeContext.LoadFunction("SDL_CloseIO", "SDL3") + ) + )(context); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK \"SDL_JOYSTICK_HIDAPI_STEAMDECK\"")] - public static Utf8String HintJoystickHidapiSteamdeck => "SDL_JOYSTICK_HIDAPI_STEAMDECK"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CloseIORaw(IOStreamHandle context) => DllImport.CloseIORaw(context); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI \"SDL_JOYSTICK_HIDAPI_STEAM_HORI\"" - )] - public static Utf8String HintJoystickHidapiSteamHori => "SDL_JOYSTICK_HIDAPI_STEAM_HORI"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseJoystick(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[76] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[76] = nativeContext.LoadFunction("SDL_CloseJoystick", "SDL3") + ) + )(joystick); + + [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseJoystick(JoystickHandle joystick) => DllImport.CloseJoystick(joystick); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH \"SDL_JOYSTICK_HIDAPI_SWITCH\"")] - public static Utf8String HintJoystickHidapiSwitch => "SDL_JOYSTICK_HIDAPI_SWITCH"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CloseSensor(SensorHandle sensor) => + ( + (delegate* unmanaged)( + _slots[77] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[77] = nativeContext.LoadFunction("SDL_CloseSensor", "SDL3") + ) + )(sensor); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED \"SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED\"" - )] - public static Utf8String HintJoystickHidapiSwitchHomeLed => - "SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CloseSensor(SensorHandle sensor) => DllImport.CloseSensor(sensor); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED\"" - )] - public static Utf8String HintJoystickHidapiSwitchPlayerLed => - "SDL_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CloseStorage(StorageHandle storage) => + (MaybeBool)(byte)((ISdl)this).CloseStorageRaw(storage); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS \"SDL_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS\"" - )] - public static Utf8String HintJoystickHidapiVerticalJoyCons => - "SDL_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CloseStorage(StorageHandle storage) => + DllImport.CloseStorage(storage); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_WII \"SDL_JOYSTICK_HIDAPI_WII\"")] - public static Utf8String HintJoystickHidapiWii => "SDL_JOYSTICK_HIDAPI_WII"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CloseStorageRaw(StorageHandle storage) => + ( + (delegate* unmanaged)( + _slots[78] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[78] = nativeContext.LoadFunction("SDL_CloseStorage", "SDL3") + ) + )(storage); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_WII_PLAYER_LED\"" - )] - public static Utf8String HintJoystickHidapiWiiPlayerLed => - "SDL_JOYSTICK_HIDAPI_WII_PLAYER_LED"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CloseStorageRaw(StorageHandle storage) => DllImport.CloseStorageRaw(storage); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX \"SDL_JOYSTICK_HIDAPI_XBOX\"")] - public static Utf8String HintJoystickHidapiXbox => "SDL_JOYSTICK_HIDAPI_XBOX"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => + ( + (delegate* unmanaged)( + _slots[79] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[79] = nativeContext.LoadFunction("SDL_CompareAndSwapAtomicInt", "SDL3") + ) + )(a, oldval, newval); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360 \"SDL_JOYSTICK_HIDAPI_XBOX_360\"")] - public static Utf8String HintJoystickHidapiXbox360 => "SDL_JOYSTICK_HIDAPI_XBOX_360"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => + DllImport.CompareAndSwapAtomicInt(a, oldval, newval); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED \"SDL_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED\"" - )] - public static Utf8String HintJoystickHidapiXbox360PlayerLed => - "SDL_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CompareAndSwapAtomicInt(Ref a, int oldval, int newval) + { + fixed (AtomicInt* __dsl_a = a) + { + return (MaybeBool) + (byte)((ISdl)this).CompareAndSwapAtomicInt(__dsl_a, oldval, newval); + } + } - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS \"SDL_JOYSTICK_HIDAPI_XBOX_360_WIRELESS\"" - )] - public static Utf8String HintJoystickHidapiXbox360Wireless => - "SDL_JOYSTICK_HIDAPI_XBOX_360_WIRELESS"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CompareAndSwapAtomicInt( + Ref a, + int oldval, + int newval + ) => DllImport.CompareAndSwapAtomicInt(a, oldval, newval); - [NativeTypeName("#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE \"SDL_JOYSTICK_HIDAPI_XBOX_ONE\"")] - public static Utf8String HintJoystickHidapiXboxOne => "SDL_JOYSTICK_HIDAPI_XBOX_ONE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => + ( + (delegate* unmanaged)( + _slots[80] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[80] = nativeContext.LoadFunction( + "SDL_CompareAndSwapAtomicPointer", + "SDL3" + ) + ) + )(a, oldval, newval); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED \"SDL_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED\"" - )] - public static Utf8String HintJoystickHidapiXboxOneHomeLed => - "SDL_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => + DllImport.CompareAndSwapAtomicPointer(a, oldval, newval); - [NativeTypeName("#define SDL_HINT_JOYSTICK_IOKIT \"SDL_JOYSTICK_IOKIT\"")] - public static Utf8String HintJoystickIokit => "SDL_JOYSTICK_IOKIT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) + { + fixed (void* __dsl_newval = newval) + fixed (void* __dsl_oldval = oldval) + fixed (void** __dsl_a = a) + { + return (MaybeBool) + (byte)((ISdl)this).CompareAndSwapAtomicPointer(__dsl_a, __dsl_oldval, __dsl_newval); + } + } - [NativeTypeName("#define SDL_HINT_JOYSTICK_LINUX_CLASSIC \"SDL_JOYSTICK_LINUX_CLASSIC\"")] - public static Utf8String HintJoystickLinuxClassic => "SDL_JOYSTICK_LINUX_CLASSIC"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) => + DllImport.CompareAndSwapAtomicPointer(a, oldval, newval); - [NativeTypeName("#define SDL_HINT_JOYSTICK_LINUX_DEADZONES \"SDL_JOYSTICK_LINUX_DEADZONES\"")] - public static Utf8String HintJoystickLinuxDeadzones => "SDL_JOYSTICK_LINUX_DEADZONES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CompareAndSwapAtomicU32( + AtomicU32* a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => + ( + (delegate* unmanaged)( + _slots[81] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[81] = nativeContext.LoadFunction("SDL_CompareAndSwapAtomicU32", "SDL3") + ) + )(a, oldval, newval); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_LINUX_DIGITAL_HATS \"SDL_JOYSTICK_LINUX_DIGITAL_HATS\"" - )] - public static Utf8String HintJoystickLinuxDigitalHats => "SDL_JOYSTICK_LINUX_DIGITAL_HATS"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CompareAndSwapAtomicU32( + AtomicU32* a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => DllImport.CompareAndSwapAtomicU32(a, oldval, newval); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_LINUX_HAT_DEADZONES \"SDL_JOYSTICK_LINUX_HAT_DEADZONES\"" - )] - public static Utf8String HintJoystickLinuxHatDeadzones => "SDL_JOYSTICK_LINUX_HAT_DEADZONES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CompareAndSwapAtomicU32( + Ref a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) + { + fixed (AtomicU32* __dsl_a = a) + { + return (MaybeBool) + (byte)((ISdl)this).CompareAndSwapAtomicU32(__dsl_a, oldval, newval); + } + } - [NativeTypeName("#define SDL_HINT_JOYSTICK_MFI \"SDL_JOYSTICK_MFI\"")] - public static Utf8String HintJoystickMfi => "SDL_JOYSTICK_MFI"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CompareAndSwapAtomicU32( + Ref a, + [NativeTypeName("Uint32")] uint oldval, + [NativeTypeName("Uint32")] uint newval + ) => DllImport.CompareAndSwapAtomicU32(a, oldval, newval); - [NativeTypeName("#define SDL_HINT_JOYSTICK_RAWINPUT \"SDL_JOYSTICK_RAWINPUT\"")] - public static Utf8String HintJoystickRawinput => "SDL_JOYSTICK_RAWINPUT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.ComposeCustomBlendMode( + BlendFactor srcColorFactor, + BlendFactor dstColorFactor, + BlendOperation colorOperation, + BlendFactor srcAlphaFactor, + BlendFactor dstAlphaFactor, + BlendOperation alphaOperation + ) => + ( + (delegate* unmanaged< + BlendFactor, + BlendFactor, + BlendOperation, + BlendFactor, + BlendFactor, + BlendOperation, + uint>)( + _slots[82] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[82] = nativeContext.LoadFunction("SDL_ComposeCustomBlendMode", "SDL3") + ) + )( + srcColorFactor, + dstColorFactor, + colorOperation, + srcAlphaFactor, + dstAlphaFactor, + alphaOperation + ); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT \"SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT\"" - )] - public static Utf8String HintJoystickRawinputCorrelateXinput => - "SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT"u8; + [return: NativeTypeName("SDL_BlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint ComposeCustomBlendMode( + BlendFactor srcColorFactor, + BlendFactor dstColorFactor, + BlendOperation colorOperation, + BlendFactor srcAlphaFactor, + BlendFactor dstAlphaFactor, + BlendOperation alphaOperation + ) => + DllImport.ComposeCustomBlendMode( + srcColorFactor, + dstColorFactor, + colorOperation, + srcAlphaFactor, + dstAlphaFactor, + alphaOperation + ); - [NativeTypeName("#define SDL_HINT_JOYSTICK_ROG_CHAKRAM \"SDL_JOYSTICK_ROG_CHAKRAM\"")] - public static Utf8String HintJoystickRogChakram => "SDL_JOYSTICK_ROG_CHAKRAM"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const Uint8 *")] byte* src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, + [NativeTypeName("Uint8 **")] byte** dst_data, + int* dst_len + ) => + ( + (delegate* unmanaged)( + _slots[83] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[83] = nativeContext.LoadFunction("SDL_ConvertAudioSamples", "SDL3") + ) + )(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); - [NativeTypeName("#define SDL_HINT_JOYSTICK_THREAD \"SDL_JOYSTICK_THREAD\"")] - public static Utf8String HintJoystickThread => "SDL_JOYSTICK_THREAD"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const Uint8 *")] byte* src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, + [NativeTypeName("Uint8 **")] byte** dst_data, + int* dst_len + ) => DllImport.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); - [NativeTypeName("#define SDL_HINT_JOYSTICK_THROTTLE_DEVICES \"SDL_JOYSTICK_THROTTLE_DEVICES\"")] - public static Utf8String HintJoystickThrottleDevices => "SDL_JOYSTICK_THROTTLE_DEVICES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const Uint8 *")] Ref src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, + [NativeTypeName("Uint8 **")] Ref2D dst_data, + Ref dst_len + ) + { + fixed (int* __dsl_dst_len = dst_len) + fixed (byte** __dsl_dst_data = dst_data) + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (byte* __dsl_src_data = src_data) + fixed (AudioSpec* __dsl_src_spec = src_spec) + { + return (MaybeBool) + (byte) + ((ISdl)this).ConvertAudioSamples( + __dsl_src_spec, + __dsl_src_data, + src_len, + __dsl_dst_spec, + __dsl_dst_data, + __dsl_dst_len + ); + } + } - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_THROTTLE_DEVICES_EXCLUDED \"SDL_JOYSTICK_THROTTLE_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickThrottleDevicesExcluded => - "SDL_JOYSTICK_THROTTLE_DEVICES_EXCLUDED"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ConvertAudioSamples( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const Uint8 *")] Ref src_data, + int src_len, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, + [NativeTypeName("Uint8 **")] Ref2D dst_data, + Ref dst_len + ) => DllImport.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); - [NativeTypeName("#define SDL_HINT_JOYSTICK_WGI \"SDL_JOYSTICK_WGI\"")] - public static Utf8String HintJoystickWgi => "SDL_JOYSTICK_WGI"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => + ( + (delegate* unmanaged)( + _slots[84] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[84] = nativeContext.LoadFunction( + "SDL_ConvertEventToRenderCoordinates", + "SDL3" + ) + ) + )(renderer, @event); - [NativeTypeName("#define SDL_HINT_JOYSTICK_WHEEL_DEVICES \"SDL_JOYSTICK_WHEEL_DEVICES\"")] - public static Utf8String HintJoystickWheelDevices => "SDL_JOYSTICK_WHEEL_DEVICES"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => + DllImport.ConvertEventToRenderCoordinates(renderer, @event); - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_WHEEL_DEVICES_EXCLUDED \"SDL_JOYSTICK_WHEEL_DEVICES_EXCLUDED\"" - )] - public static Utf8String HintJoystickWheelDevicesExcluded => - "SDL_JOYSTICK_WHEEL_DEVICES_EXCLUDED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ConvertEventToRenderCoordinates(RendererHandle renderer, Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool) + (byte)((ISdl)this).ConvertEventToRenderCoordinates(renderer, __dsl_event); + } + } - [NativeTypeName( - "#define SDL_HINT_JOYSTICK_ZERO_CENTERED_DEVICES \"SDL_JOYSTICK_ZERO_CENTERED_DEVICES\"" - )] - public static Utf8String HintJoystickZeroCenteredDevices => - "SDL_JOYSTICK_ZERO_CENTERED_DEVICES"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ConvertEventToRenderCoordinates( + RendererHandle renderer, + Ref @event + ) => DllImport.ConvertEventToRenderCoordinates(renderer, @event); - [NativeTypeName("#define SDL_HINT_KEYCODE_OPTIONS \"SDL_KEYCODE_OPTIONS\"")] - public static Utf8String HintKeycodeOptions => "SDL_KEYCODE_OPTIONS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch + ) => + ( + (delegate* unmanaged)( + _slots[85] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[85] = nativeContext.LoadFunction("SDL_ConvertPixels", "SDL3") + ) + )(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); - [NativeTypeName("#define SDL_HINT_KMSDRM_DEVICE_INDEX \"SDL_KMSDRM_DEVICE_INDEX\"")] - public static Utf8String HintKmsdrmDeviceIndex => "SDL_KMSDRM_DEVICE_INDEX"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch + ) => + DllImport.ConvertPixels( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch + ); - [NativeTypeName("#define SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER \"SDL_KMSDRM_REQUIRE_DRM_MASTER\"")] - public static Utf8String HintKmsdrmRequireDrmMaster => "SDL_KMSDRM_REQUIRE_DRM_MASTER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch + ) + { + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).ConvertPixels( + width, + height, + src_format, + __dsl_src, + src_pitch, + dst_format, + __dsl_dst, + dst_pitch + ); + } + } - [NativeTypeName("#define SDL_HINT_LOGGING \"SDL_LOGGING\"")] - public static Utf8String HintLogging => "SDL_LOGGING"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ConvertPixels( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch + ) => + DllImport.ConvertPixels( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch + ); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + void* dst, + int dst_pitch + ) => + ( + (delegate* unmanaged< + int, + int, + PixelFormat, + Colorspace, + uint, + void*, + int, + PixelFormat, + Colorspace, + uint, + void*, + int, + byte>)( + _slots[86] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[86] = nativeContext.LoadFunction( + "SDL_ConvertPixelsAndColorspace", + "SDL3" + ) + ) + )( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); - [NativeTypeName("#define SDL_HINT_MAC_BACKGROUND_APP \"SDL_MAC_BACKGROUND_APP\"")] - public static Utf8String HintMacBackgroundApp => "SDL_MAC_BACKGROUND_APP"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + void* dst, + int dst_pitch + ) => + DllImport.ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); - [NativeTypeName( - "#define SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK \"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK\"" - )] - public static Utf8String HintMacCtrlClickEmulateRightClick => - "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + Ref dst, + int dst_pitch + ) + { + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + __dsl_src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + __dsl_dst, + dst_pitch + ); + } + } - [NativeTypeName("#define SDL_HINT_MAC_OPENGL_ASYNC_DISPATCH \"SDL_MAC_OPENGL_ASYNC_DISPATCH\"")] - public static Utf8String HintMacOpenglAsyncDispatch => "SDL_MAC_OPENGL_ASYNC_DISPATCH"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ConvertPixelsAndColorspace( + int width, + int height, + PixelFormat src_format, + Colorspace src_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint src_properties, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Colorspace dst_colorspace, + [NativeTypeName("SDL_PropertiesID")] uint dst_properties, + Ref dst, + int dst_pitch + ) => + DllImport.ConvertPixelsAndColorspace( + width, + height, + src_format, + src_colorspace, + src_properties, + src, + src_pitch, + dst_format, + dst_colorspace, + dst_properties, + dst, + dst_pitch + ); - [NativeTypeName("#define SDL_HINT_MAC_SCROLL_MOMENTUM \"SDL_MAC_SCROLL_MOMENTUM\"")] - public static Utf8String HintMacScrollMomentum => "SDL_MAC_SCROLL_MOMENTUM"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.ConvertSurface(Surface* surface, PixelFormat format) => + ( + (delegate* unmanaged)( + _slots[87] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[87] = nativeContext.LoadFunction("SDL_ConvertSurface", "SDL3") + ) + )(surface, format); - [NativeTypeName("#define SDL_HINT_MAIN_CALLBACK_RATE \"SDL_MAIN_CALLBACK_RATE\"")] - public static Utf8String HintMainCallbackRate => "SDL_MAIN_CALLBACK_RATE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* ConvertSurface(Surface* surface, PixelFormat format) => + DllImport.ConvertSurface(surface, format); - [NativeTypeName("#define SDL_HINT_MOUSE_AUTO_CAPTURE \"SDL_MOUSE_AUTO_CAPTURE\"")] - public static Utf8String HintMouseAutoCapture => "SDL_MOUSE_AUTO_CAPTURE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.ConvertSurface(Ref surface, PixelFormat format) + { + fixed (Surface* __dsl_surface = surface) + { + return (Surface*)((ISdl)this).ConvertSurface(__dsl_surface, format); + } + } - [NativeTypeName("#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS \"SDL_MOUSE_DOUBLE_CLICK_RADIUS\"")] - public static Utf8String HintMouseDoubleClickRadius => "SDL_MOUSE_DOUBLE_CLICK_RADIUS"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr ConvertSurface(Ref surface, PixelFormat format) => + DllImport.ConvertSurface(surface, format); - [NativeTypeName("#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME \"SDL_MOUSE_DOUBLE_CLICK_TIME\"")] - public static Utf8String HintMouseDoubleClickTime => "SDL_MOUSE_DOUBLE_CLICK_TIME"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.ConvertSurfaceAndColorspace( + Surface* surface, + PixelFormat format, + Palette* palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[88] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[88] = nativeContext.LoadFunction( + "SDL_ConvertSurfaceAndColorspace", + "SDL3" + ) + ) + )(surface, format, palette, colorspace, props); - [NativeTypeName( - "#define SDL_HINT_MOUSE_EMULATE_WARP_WITH_RELATIVE \"SDL_MOUSE_EMULATE_WARP_WITH_RELATIVE\"" - )] - public static Utf8String HintMouseEmulateWarpWithRelative => - "SDL_MOUSE_EMULATE_WARP_WITH_RELATIVE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* ConvertSurfaceAndColorspace( + Surface* surface, + PixelFormat format, + Palette* palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); - [NativeTypeName("#define SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH \"SDL_MOUSE_FOCUS_CLICKTHROUGH\"")] - public static Utf8String HintMouseFocusClickthrough => "SDL_MOUSE_FOCUS_CLICKTHROUGH"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.ConvertSurfaceAndColorspace( + Ref surface, + PixelFormat format, + Ref palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) + { + fixed (Palette* __dsl_palette = palette) + fixed (Surface* __dsl_surface = surface) + { + return (Surface*) + ((ISdl)this).ConvertSurfaceAndColorspace( + __dsl_surface, + format, + __dsl_palette, + colorspace, + props + ); + } + } - [NativeTypeName("#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE \"SDL_MOUSE_NORMAL_SPEED_SCALE\"")] - public static Utf8String HintMouseNormalSpeedScale => "SDL_MOUSE_NORMAL_SPEED_SCALE"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr ConvertSurfaceAndColorspace( + Ref surface, + PixelFormat format, + Ref palette, + Colorspace colorspace, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_MODE_CENTER \"SDL_MOUSE_RELATIVE_MODE_CENTER\"" - )] - public static Utf8String HintMouseRelativeModeCenter => "SDL_MOUSE_RELATIVE_MODE_CENTER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CopyFile( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => + ( + (delegate* unmanaged)( + _slots[89] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[89] = nativeContext.LoadFunction("SDL_CopyFile", "SDL3") + ) + )(oldpath, newpath); - [NativeTypeName("#define SDL_HINT_MOUSE_RELATIVE_MODE_WARP \"SDL_MOUSE_RELATIVE_MODE_WARP\"")] - public static Utf8String HintMouseRelativeModeWarp => "SDL_MOUSE_RELATIVE_MODE_WARP"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CopyFile( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => DllImport.CopyFile(oldpath, newpath); - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE \"SDL_MOUSE_RELATIVE_SPEED_SCALE\"" - )] - public static Utf8String HintMouseRelativeSpeedScale => "SDL_MOUSE_RELATIVE_SPEED_SCALE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CopyFile( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) + { + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) + { + return (MaybeBool)(byte)((ISdl)this).CopyFile(__dsl_oldpath, __dsl_newpath); + } + } - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE \"SDL_MOUSE_RELATIVE_SYSTEM_SCALE\"" - )] - public static Utf8String HintMouseRelativeSystemScale => "SDL_MOUSE_RELATIVE_SYSTEM_SCALE"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CopyFile( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => DllImport.CopyFile(oldpath, newpath); - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_WARP_MOTION \"SDL_MOUSE_RELATIVE_WARP_MOTION\"" - )] - public static Utf8String HintMouseRelativeWarpMotion => "SDL_MOUSE_RELATIVE_WARP_MOTION"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ) => + ( + (delegate* unmanaged< + GPUCopyPassHandle, + GPUBufferLocation*, + GPUBufferLocation*, + uint, + byte, + void>)( + _slots[90] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[90] = nativeContext.LoadFunction("SDL_CopyGPUBufferToBuffer", "SDL3") + ) + )(copy_pass, source, destination, size, cycle); - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE \"SDL_MOUSE_RELATIVE_CURSOR_VISIBLE\"" - )] - public static Utf8String HintMouseRelativeCursorVisible => - "SDL_MOUSE_RELATIVE_CURSOR_VISIBLE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferLocation *")] GPUBufferLocation* destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] byte cycle + ) => DllImport.CopyGPUBufferToBuffer(copy_pass, source, destination, size, cycle); - [NativeTypeName( - "#define SDL_HINT_MOUSE_RELATIVE_CLIP_INTERVAL \"SDL_MOUSE_RELATIVE_CLIP_INTERVAL\"" - )] - public static Utf8String HintMouseRelativeClipInterval => "SDL_MOUSE_RELATIVE_CLIP_INTERVAL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUBufferLocation* __dsl_destination = destination) + fixed (GPUBufferLocation* __dsl_source = source) + { + ((ISdl)this).CopyGPUBufferToBuffer( + copy_pass, + __dsl_source, + __dsl_destination, + size, + (byte)cycle + ); + } + } - [NativeTypeName("#define SDL_HINT_MOUSE_TOUCH_EVENTS \"SDL_MOUSE_TOUCH_EVENTS\"")] - public static Utf8String HintMouseTouchEvents => "SDL_MOUSE_TOUCH_EVENTS"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUBufferToBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CopyGPUBufferToBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref source, + [NativeTypeName("const SDL_GPUBufferLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint size, + [NativeTypeName("bool")] MaybeBool cycle + ) => DllImport.CopyGPUBufferToBuffer(copy_pass, source, destination, size, cycle); - [NativeTypeName("#define SDL_HINT_MUTE_CONSOLE_KEYBOARD \"SDL_MUTE_CONSOLE_KEYBOARD\"")] - public static Utf8String HintMuteConsoleKeyboard => "SDL_MUTE_CONSOLE_KEYBOARD"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ) => + ( + (delegate* unmanaged< + GPUCopyPassHandle, + GPUTextureLocation*, + GPUTextureLocation*, + uint, + uint, + uint, + byte, + void>)( + _slots[91] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[91] = nativeContext.LoadFunction("SDL_CopyGPUTextureToTexture", "SDL3") + ) + )(copy_pass, source, destination, w, h, d, cycle); - [NativeTypeName("#define SDL_HINT_NO_SIGNAL_HANDLERS \"SDL_NO_SIGNAL_HANDLERS\"")] - public static Utf8String HintNoSignalHandlers => "SDL_NO_SIGNAL_HANDLERS"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* source, + [NativeTypeName("const SDL_GPUTextureLocation *")] GPUTextureLocation* destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] byte cycle + ) => DllImport.CopyGPUTextureToTexture(copy_pass, source, destination, w, h, d, cycle); - [NativeTypeName("#define SDL_HINT_OPENGL_LIBRARY \"SDL_OPENGL_LIBRARY\"")] - public static Utf8String HintOpenglLibrary => "SDL_OPENGL_LIBRARY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUTextureLocation* __dsl_destination = destination) + fixed (GPUTextureLocation* __dsl_source = source) + { + ((ISdl)this).CopyGPUTextureToTexture( + copy_pass, + __dsl_source, + __dsl_destination, + w, + h, + d, + (byte)cycle + ); + } + } - [NativeTypeName("#define SDL_HINT_OPENGL_ES_DRIVER \"SDL_OPENGL_ES_DRIVER\"")] - public static Utf8String HintOpenglEsDriver => "SDL_OPENGL_ES_DRIVER"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyGPUTextureToTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void CopyGPUTextureToTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref source, + [NativeTypeName("const SDL_GPUTextureLocation *")] Ref destination, + [NativeTypeName("Uint32")] uint w, + [NativeTypeName("Uint32")] uint h, + [NativeTypeName("Uint32")] uint d, + [NativeTypeName("bool")] MaybeBool cycle + ) => DllImport.CopyGPUTextureToTexture(copy_pass, source, destination, w, h, d, cycle); - [NativeTypeName("#define SDL_HINT_OPENVR_LIBRARY \"SDL_OPENVR_LIBRARY\"")] - public static Utf8String HintOpenvrLibrary => "SDL_OPENVR_LIBRARY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CopyProperties( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => (MaybeBool)(byte)((ISdl)this).CopyPropertiesRaw(src, dst); - [NativeTypeName("#define SDL_HINT_ORIENTATIONS \"SDL_ORIENTATIONS\"")] - public static Utf8String HintOrientations => "SDL_ORIENTATIONS"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CopyProperties( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => DllImport.CopyProperties(src, dst); - [NativeTypeName("#define SDL_HINT_POLL_SENTINEL \"SDL_POLL_SENTINEL\"")] - public static Utf8String HintPollSentinel => "SDL_POLL_SENTINEL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CopyPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => + ( + (delegate* unmanaged)( + _slots[92] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[92] = nativeContext.LoadFunction("SDL_CopyProperties", "SDL3") + ) + )(src, dst); - [NativeTypeName("#define SDL_HINT_PREFERRED_LOCALES \"SDL_PREFERRED_LOCALES\"")] - public static Utf8String HintPreferredLocales => "SDL_PREFERRED_LOCALES"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CopyPropertiesRaw( + [NativeTypeName("SDL_PropertiesID")] uint src, + [NativeTypeName("SDL_PropertiesID")] uint dst + ) => DllImport.CopyPropertiesRaw(src, dst); - [NativeTypeName("#define SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE \"SDL_QUIT_ON_LAST_WINDOW_CLOSE\"")] - public static Utf8String HintQuitOnLastWindowClose => "SDL_QUIT_ON_LAST_WINDOW_CLOSE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Copysign(double x, double y) => + ( + (delegate* unmanaged)( + _slots[93] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[93] = nativeContext.LoadFunction("SDL_copysign", "SDL3") + ) + )(x, y); - [NativeTypeName( - "#define SDL_HINT_RENDER_DIRECT3D_THREADSAFE \"SDL_RENDER_DIRECT3D_THREADSAFE\"" - )] - public static Utf8String HintRenderDirect3DThreadsafe => "SDL_RENDER_DIRECT3D_THREADSAFE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_copysign")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Copysign(double x, double y) => DllImport.Copysign(x, y); - [NativeTypeName("#define SDL_HINT_RENDER_DIRECT3D11_DEBUG \"SDL_RENDER_DIRECT3D11_DEBUG\"")] - public static Utf8String HintRenderDirect3D11Debug => "SDL_RENDER_DIRECT3D11_DEBUG"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Copysignf(float x, float y) => + ( + (delegate* unmanaged)( + _slots[94] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[94] = nativeContext.LoadFunction("SDL_copysignf", "SDL3") + ) + )(x, y); - [NativeTypeName("#define SDL_HINT_RENDER_VULKAN_DEBUG \"SDL_RENDER_VULKAN_DEBUG\"")] - public static Utf8String HintRenderVulkanDebug => "SDL_RENDER_VULKAN_DEBUG"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_copysignf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Copysignf(float x, float y) => DllImport.Copysignf(x, y); - [NativeTypeName("#define SDL_HINT_RENDER_GPU_DEBUG \"SDL_RENDER_GPU_DEBUG\"")] - public static Utf8String HintRenderGpuDebug => "SDL_RENDER_GPU_DEBUG"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => + ( + (delegate* unmanaged)( + _slots[95] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[95] = nativeContext.LoadFunction("SDL_CopyStorageFile", "SDL3") + ) + )(storage, oldpath, newpath); - [NativeTypeName("#define SDL_HINT_RENDER_GPU_LOW_POWER \"SDL_RENDER_GPU_LOW_POWER\"")] - public static Utf8String HintRenderGpuLowPower => "SDL_RENDER_GPU_LOW_POWER"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => DllImport.CopyStorageFile(storage, oldpath, newpath); - [NativeTypeName("#define SDL_HINT_RENDER_DRIVER \"SDL_RENDER_DRIVER\"")] - public static Utf8String HintRenderDriver => "SDL_RENDER_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) + { + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) + { + return (MaybeBool) + (byte)((ISdl)this).CopyStorageFile(storage, __dsl_oldpath, __dsl_newpath); + } + } - [NativeTypeName("#define SDL_HINT_RENDER_LINE_METHOD \"SDL_RENDER_LINE_METHOD\"")] - public static Utf8String HintRenderLineMethod => "SDL_RENDER_LINE_METHOD"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CopyStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => DllImport.CopyStorageFile(storage, oldpath, newpath); - [NativeTypeName( - "#define SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE \"SDL_RENDER_METAL_PREFER_LOW_POWER_DEVICE\"" - )] - public static Utf8String HintRenderMetalPreferLowPowerDevice => - "SDL_RENDER_METAL_PREFER_LOW_POWER_DEVICE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Cos(double x) => + ( + (delegate* unmanaged)( + _slots[96] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[96] = nativeContext.LoadFunction("SDL_cos", "SDL3") + ) + )(x); - [NativeTypeName("#define SDL_HINT_RENDER_VSYNC \"SDL_RENDER_VSYNC\"")] - public static Utf8String HintRenderVsync => "SDL_RENDER_VSYNC"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_cos")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Cos(double x) => DllImport.Cos(x); - [NativeTypeName("#define SDL_HINT_RETURN_KEY_HIDES_IME \"SDL_RETURN_KEY_HIDES_IME\"")] - public static Utf8String HintReturnKeyHidesIme => "SDL_RETURN_KEY_HIDES_IME"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Cosf(float x) => + ( + (delegate* unmanaged)( + _slots[97] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[97] = nativeContext.LoadFunction("SDL_cosf", "SDL3") + ) + )(x); - [NativeTypeName("#define SDL_HINT_ROG_GAMEPAD_MICE \"SDL_ROG_GAMEPAD_MICE\"")] - public static Utf8String HintRogGamepadMice => "SDL_ROG_GAMEPAD_MICE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_cosf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Cosf(float x) => DllImport.Cosf(x); - [NativeTypeName("#define SDL_HINT_ROG_GAMEPAD_MICE_EXCLUDED \"SDL_ROG_GAMEPAD_MICE_EXCLUDED\"")] - public static Utf8String HintRogGamepadMiceExcluded => "SDL_ROG_GAMEPAD_MICE_EXCLUDED"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ushort ISdl.Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => + ( + (delegate* unmanaged)( + _slots[98] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[98] = nativeContext.LoadFunction("SDL_crc16", "SDL3") + ) + )(crc, data, len); - [NativeTypeName("#define SDL_HINT_RPI_VIDEO_LAYER \"SDL_RPI_VIDEO_LAYER\"")] - public static Utf8String HintRpiVideoLayer => "SDL_RPI_VIDEO_LAYER"u8; + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Crc16(crc, data, len); - [NativeTypeName( - "#define SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME \"SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME\"" - )] - public static Utf8String HintScreensaverInhibitActivityName => - "SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ushort ISdl.Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_data = data) + { + return (ushort)((ISdl)this).Crc16(crc, __dsl_data, len); + } + } - [NativeTypeName("#define SDL_HINT_SHUTDOWN_DBUS_ON_QUIT \"SDL_SHUTDOWN_DBUS_ON_QUIT\"")] - public static Utf8String HintShutdownDbusOnQuit => "SDL_SHUTDOWN_DBUS_ON_QUIT"u8; + [return: NativeTypeName("Uint16")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc16")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ushort Crc16( + [NativeTypeName("Uint16")] ushort crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Crc16(crc, data, len); - [NativeTypeName("#define SDL_HINT_STORAGE_TITLE_DRIVER \"SDL_STORAGE_TITLE_DRIVER\"")] - public static Utf8String HintStorageTitleDriver => "SDL_STORAGE_TITLE_DRIVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => + ( + (delegate* unmanaged)( + _slots[99] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[99] = nativeContext.LoadFunction("SDL_crc32", "SDL3") + ) + )(crc, data, len); - [NativeTypeName("#define SDL_HINT_STORAGE_USER_DRIVER \"SDL_STORAGE_USER_DRIVER\"")] - public static Utf8String HintStorageUserDriver => "SDL_STORAGE_USER_DRIVER"u8; + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Crc32(crc, data, len); - [NativeTypeName( - "#define SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL \"SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL\"" - )] - public static Utf8String HintThreadForceRealtimeTimeCritical => - "SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_data = data) + { + return (uint)((ISdl)this).Crc32(crc, __dsl_data, len); + } + } - [NativeTypeName("#define SDL_HINT_THREAD_PRIORITY_POLICY \"SDL_THREAD_PRIORITY_POLICY\"")] - public static Utf8String HintThreadPriorityPolicy => "SDL_THREAD_PRIORITY_POLICY"u8; + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_crc32")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint Crc32( + [NativeTypeName("Uint32")] uint crc, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Crc32(crc, data, len); - [NativeTypeName("#define SDL_HINT_TIMER_RESOLUTION \"SDL_TIMER_RESOLUTION\"")] - public static Utf8String HintTimerResolution => "SDL_TIMER_RESOLUTION"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + AudioStreamHandle ISdl.CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => + ( + (delegate* unmanaged)( + _slots[100] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[100] = nativeContext.LoadFunction("SDL_CreateAudioStream", "SDL3") + ) + )(src_spec, dst_spec); - [NativeTypeName("#define SDL_HINT_TOUCH_MOUSE_EVENTS \"SDL_TOUCH_MOUSE_EVENTS\"")] - public static Utf8String HintTouchMouseEvents => "SDL_TOUCH_MOUSE_EVENTS"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => DllImport.CreateAudioStream(src_spec, dst_spec); - [NativeTypeName("#define SDL_HINT_TRACKPAD_IS_TOUCH_ONLY \"SDL_TRACKPAD_IS_TOUCH_ONLY\"")] - public static Utf8String HintTrackpadIsTouchOnly => "SDL_TRACKPAD_IS_TOUCH_ONLY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + AudioStreamHandle ISdl.CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) + { + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) + { + return (AudioStreamHandle) + ((ISdl)this).CreateAudioStream(__dsl_src_spec, __dsl_dst_spec); + } + } - [NativeTypeName("#define SDL_HINT_TV_REMOTE_AS_JOYSTICK \"SDL_TV_REMOTE_AS_JOYSTICK\"")] - public static Utf8String HintTvRemoteAsJoystick => "SDL_TV_REMOTE_AS_JOYSTICK"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static AudioStreamHandle CreateAudioStream( + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) => DllImport.CreateAudioStream(src_spec, dst_spec); - [NativeTypeName("#define SDL_HINT_VIDEO_ALLOW_SCREENSAVER \"SDL_VIDEO_ALLOW_SCREENSAVER\"")] - public static Utf8String HintVideoAllowScreensaver => "SDL_VIDEO_ALLOW_SCREENSAVER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + CursorHandle ISdl.CreateColorCursor(Surface* surface, int hot_x, int hot_y) => + ( + (delegate* unmanaged)( + _slots[101] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[101] = nativeContext.LoadFunction("SDL_CreateColorCursor", "SDL3") + ) + )(surface, hot_x, hot_y); - [NativeTypeName("#define SDL_HINT_VIDEO_DISPLAY_PRIORITY \"SDL_VIDEO_DISPLAY_PRIORITY\"")] - public static Utf8String HintVideoDisplayPriority => "SDL_VIDEO_DISPLAY_PRIORITY"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => + DllImport.CreateColorCursor(surface, hot_x, hot_y); - [NativeTypeName("#define SDL_HINT_VIDEO_DOUBLE_BUFFER \"SDL_VIDEO_DOUBLE_BUFFER\"")] - public static Utf8String HintVideoDoubleBuffer => "SDL_VIDEO_DOUBLE_BUFFER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + CursorHandle ISdl.CreateColorCursor(Ref surface, int hot_x, int hot_y) + { + fixed (Surface* __dsl_surface = surface) + { + return (CursorHandle)((ISdl)this).CreateColorCursor(__dsl_surface, hot_x, hot_y); + } + } - [NativeTypeName("#define SDL_HINT_VIDEO_DRIVER \"SDL_VIDEO_DRIVER\"")] - public static Utf8String HintVideoDriver => "SDL_VIDEO_DRIVER"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) => + DllImport.CreateColorCursor(surface, hot_x, hot_y); - [NativeTypeName("#define SDL_HINT_VIDEO_DUMMY_SAVE_FRAMES \"SDL_VIDEO_DUMMY_SAVE_FRAMES\"")] - public static Utf8String HintVideoDummySaveFrames => "SDL_VIDEO_DUMMY_SAVE_FRAMES"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ConditionHandle ISdl.CreateCondition() => + ( + (delegate* unmanaged)( + _slots[102] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[102] = nativeContext.LoadFunction("SDL_CreateCondition", "SDL3") + ) + )(); - [NativeTypeName( - "#define SDL_HINT_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK \"SDL_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK\"" - )] - public static Utf8String HintVideoEglAllowGetdisplayFallback => - "SDL_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ConditionHandle CreateCondition() => DllImport.CreateCondition(); - [NativeTypeName("#define SDL_HINT_VIDEO_FORCE_EGL \"SDL_VIDEO_FORCE_EGL\"")] - public static Utf8String HintVideoForceEgl => "SDL_VIDEO_FORCE_EGL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + CursorHandle ISdl.CreateCursor( + [NativeTypeName("const Uint8 *")] byte* data, + [NativeTypeName("const Uint8 *")] byte* mask, + int w, + int h, + int hot_x, + int hot_y + ) => + ( + (delegate* unmanaged)( + _slots[103] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[103] = nativeContext.LoadFunction("SDL_CreateCursor", "SDL3") + ) + )(data, mask, w, h, hot_x, hot_y); - [NativeTypeName( - "#define SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES \"SDL_VIDEO_MAC_FULLSCREEN_SPACES\"" - )] - public static Utf8String HintVideoMacFullscreenSpaces => "SDL_VIDEO_MAC_FULLSCREEN_SPACES"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] byte* data, + [NativeTypeName("const Uint8 *")] byte* mask, + int w, + int h, + int hot_x, + int hot_y + ) => DllImport.CreateCursor(data, mask, w, h, hot_x, hot_y); - [NativeTypeName( - "#define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS \"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\"" - )] - public static Utf8String HintVideoMinimizeOnFocusLoss => "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + CursorHandle ISdl.CreateCursor( + [NativeTypeName("const Uint8 *")] Ref data, + [NativeTypeName("const Uint8 *")] Ref mask, + int w, + int h, + int hot_x, + int hot_y + ) + { + fixed (byte* __dsl_mask = mask) + fixed (byte* __dsl_data = data) + { + return (CursorHandle) + ((ISdl)this).CreateCursor(__dsl_data, __dsl_mask, w, h, hot_x, hot_y); + } + } - [NativeTypeName( - "#define SDL_HINT_VIDEO_OFFSCREEN_SAVE_FRAMES \"SDL_VIDEO_OFFSCREEN_SAVE_FRAMES\"" - )] - public static Utf8String HintVideoOffscreenSaveFrames => "SDL_VIDEO_OFFSCREEN_SAVE_FRAMES"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static CursorHandle CreateCursor( + [NativeTypeName("const Uint8 *")] Ref data, + [NativeTypeName("const Uint8 *")] Ref mask, + int w, + int h, + int hot_x, + int hot_y + ) => DllImport.CreateCursor(data, mask, w, h, hot_x, hot_y); - [NativeTypeName( - "#define SDL_HINT_VIDEO_SYNC_WINDOW_OPERATIONS \"SDL_VIDEO_SYNC_WINDOW_OPERATIONS\"" - )] - public static Utf8String HintVideoSyncWindowOperations => "SDL_VIDEO_SYNC_WINDOW_OPERATIONS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CreateDirectory([NativeTypeName("const char *")] sbyte* path) => + ( + (delegate* unmanaged)( + _slots[104] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[104] = nativeContext.LoadFunction("SDL_CreateDirectory", "SDL3") + ) + )(path); - [NativeTypeName( - "#define SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR \"SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR\"" - )] - public static Utf8String HintVideoWaylandAllowLibdecor => "SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => + DllImport.CreateDirectory(path); - [NativeTypeName( - "#define SDL_HINT_VIDEO_WAYLAND_MODE_EMULATION \"SDL_VIDEO_WAYLAND_MODE_EMULATION\"" - )] - public static Utf8String HintVideoWaylandModeEmulation => "SDL_VIDEO_WAYLAND_MODE_EMULATION"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CreateDirectory([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).CreateDirectory(__dsl_path); + } + } - [NativeTypeName( - "#define SDL_HINT_VIDEO_WAYLAND_MODE_SCALING \"SDL_VIDEO_WAYLAND_MODE_SCALING\"" - )] - public static Utf8String HintVideoWaylandModeScaling => "SDL_VIDEO_WAYLAND_MODE_SCALING"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CreateDirectory( + [NativeTypeName("const char *")] Ref path + ) => DllImport.CreateDirectory(path); - [NativeTypeName( - "#define SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR \"SDL_VIDEO_WAYLAND_PREFER_LIBDECOR\"" - )] - public static Utf8String HintVideoWaylandPreferLibdecor => - "SDL_VIDEO_WAYLAND_PREFER_LIBDECOR"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + EnvironmentHandle ISdl.CreateEnvironment([NativeTypeName("bool")] byte populated) => + ( + (delegate* unmanaged)( + _slots[105] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[105] = nativeContext.LoadFunction("SDL_CreateEnvironment", "SDL3") + ) + )(populated); - [NativeTypeName( - "#define SDL_HINT_VIDEO_WAYLAND_SCALE_TO_DISPLAY \"SDL_VIDEO_WAYLAND_SCALE_TO_DISPLAY\"" - )] - public static Utf8String HintVideoWaylandScaleToDisplay => - "SDL_VIDEO_WAYLAND_SCALE_TO_DISPLAY"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static EnvironmentHandle CreateEnvironment([NativeTypeName("bool")] byte populated) => + DllImport.CreateEnvironment(populated); - [NativeTypeName("#define SDL_HINT_VIDEO_WIN_D3DCOMPILER \"SDL_VIDEO_WIN_D3DCOMPILER\"")] - public static Utf8String HintVideoWinD3Dcompiler => "SDL_VIDEO_WIN_D3DCOMPILER"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + EnvironmentHandle ISdl.CreateEnvironment([NativeTypeName("bool")] MaybeBool populated) => + (EnvironmentHandle)((ISdl)this).CreateEnvironment((byte)populated); - [NativeTypeName( - "#define SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR \"SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR\"" - )] - public static Utf8String HintVideoX11NetWmBypassCompositor => - "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateEnvironment")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static EnvironmentHandle CreateEnvironment( + [NativeTypeName("bool")] MaybeBool populated + ) => DllImport.CreateEnvironment(populated); - [NativeTypeName("#define SDL_HINT_VIDEO_X11_NET_WM_PING \"SDL_VIDEO_X11_NET_WM_PING\"")] - public static Utf8String HintVideoX11NetWmPing => "SDL_VIDEO_X11_NET_WM_PING"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUBufferHandle ISdl.CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ) => + ( + (delegate* unmanaged)( + _slots[106] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[106] = nativeContext.LoadFunction("SDL_CreateGPUBuffer", "SDL3") + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_VIDEO_X11_NODIRECTCOLOR \"SDL_VIDEO_X11_NODIRECTCOLOR\"")] - public static Utf8String HintVideoX11Nodirectcolor => "SDL_VIDEO_X11_NODIRECTCOLOR"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] GPUBufferCreateInfo* createinfo + ) => DllImport.CreateGPUBuffer(device, createinfo); - [NativeTypeName("#define SDL_HINT_VIDEO_X11_SCALING_FACTOR \"SDL_VIDEO_X11_SCALING_FACTOR\"")] - public static Utf8String HintVideoX11ScalingFactor => "SDL_VIDEO_X11_SCALING_FACTOR"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUBufferHandle ISdl.CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ) + { + fixed (GPUBufferCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUBufferHandle)((ISdl)this).CreateGPUBuffer(device, __dsl_createinfo); + } + } - [NativeTypeName("#define SDL_HINT_VIDEO_X11_VISUALID \"SDL_VIDEO_X11_VISUALID\"")] - public static Utf8String HintVideoX11Visualid => "SDL_VIDEO_X11_VISUALID"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUBufferHandle CreateGPUBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUBufferCreateInfo *")] Ref createinfo + ) => DllImport.CreateGPUBuffer(device, createinfo); - [NativeTypeName("#define SDL_HINT_VIDEO_X11_WINDOW_VISUALID \"SDL_VIDEO_X11_WINDOW_VISUALID\"")] - public static Utf8String HintVideoX11WindowVisualid => "SDL_VIDEO_X11_WINDOW_VISUALID"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUComputePipelineHandle ISdl.CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ) => + ( + (delegate* unmanaged< + GPUDeviceHandle, + GPUComputePipelineCreateInfo*, + GPUComputePipelineHandle>)( + _slots[107] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[107] = nativeContext.LoadFunction( + "SDL_CreateGPUComputePipeline", + "SDL3" + ) + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_VIDEO_X11_XRANDR \"SDL_VIDEO_X11_XRANDR\"")] - public static Utf8String HintVideoX11Xrandr => "SDL_VIDEO_X11_XRANDR"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + GPUComputePipelineCreateInfo* createinfo + ) => DllImport.CreateGPUComputePipeline(device, createinfo); - [NativeTypeName("#define SDL_HINT_VITA_ENABLE_BACK_TOUCH \"SDL_VITA_ENABLE_BACK_TOUCH\"")] - public static Utf8String HintVitaEnableBackTouch => "SDL_VITA_ENABLE_BACK_TOUCH"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUComputePipelineHandle ISdl.CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUComputePipelineCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUComputePipelineHandle) + ((ISdl)this).CreateGPUComputePipeline(device, __dsl_createinfo); + } + } - [NativeTypeName("#define SDL_HINT_VITA_ENABLE_FRONT_TOUCH \"SDL_VITA_ENABLE_FRONT_TOUCH\"")] - public static Utf8String HintVitaEnableFrontTouch => "SDL_VITA_ENABLE_FRONT_TOUCH"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUComputePipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUComputePipelineHandle CreateGPUComputePipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUComputePipelineCreateInfo *")] + Ref createinfo + ) => DllImport.CreateGPUComputePipeline(device, createinfo); - [NativeTypeName("#define SDL_HINT_VITA_MODULE_PATH \"SDL_VITA_MODULE_PATH\"")] - public static Utf8String HintVitaModulePath => "SDL_VITA_MODULE_PATH"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUDeviceHandle ISdl.CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ) => + ( + (delegate* unmanaged)( + _slots[108] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[108] = nativeContext.LoadFunction("SDL_CreateGPUDevice", "SDL3") + ) + )(format_flags, debug_mode, name); - [NativeTypeName("#define SDL_HINT_VITA_PVR_INIT \"SDL_VITA_PVR_INIT\"")] - public static Utf8String HintVitaPvrInit => "SDL_VITA_PVR_INIT"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] byte debug_mode, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.CreateGPUDevice(format_flags, debug_mode, name); - [NativeTypeName("#define SDL_HINT_VITA_RESOLUTION \"SDL_VITA_RESOLUTION\"")] - public static Utf8String HintVitaResolution => "SDL_VITA_RESOLUTION"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUDeviceHandle ISdl.CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (GPUDeviceHandle) + ((ISdl)this).CreateGPUDevice(format_flags, (byte)debug_mode, __dsl_name); + } + } - [NativeTypeName("#define SDL_HINT_VITA_PVR_OPENGL \"SDL_VITA_PVR_OPENGL\"")] - public static Utf8String HintVitaPvrOpengl => "SDL_VITA_PVR_OPENGL"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUDeviceHandle CreateGPUDevice( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("bool")] MaybeBool debug_mode, + [NativeTypeName("const char *")] Ref name + ) => DllImport.CreateGPUDevice(format_flags, debug_mode, name); - [NativeTypeName("#define SDL_HINT_VITA_TOUCH_MOUSE_DEVICE \"SDL_VITA_TOUCH_MOUSE_DEVICE\"")] - public static Utf8String HintVitaTouchMouseDevice => "SDL_VITA_TOUCH_MOUSE_DEVICE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUDeviceHandle ISdl.CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[109] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[109] = nativeContext.LoadFunction( + "SDL_CreateGPUDeviceWithProperties", + "SDL3" + ) + ) + )(props); - [NativeTypeName("#define SDL_HINT_VULKAN_DISPLAY \"SDL_VULKAN_DISPLAY\"")] - public static Utf8String HintVulkanDisplay => "SDL_VULKAN_DISPLAY"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUDeviceWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUDeviceHandle CreateGPUDeviceWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateGPUDeviceWithProperties(props); - [NativeTypeName("#define SDL_HINT_VULKAN_LIBRARY \"SDL_VULKAN_LIBRARY\"")] - public static Utf8String HintVulkanLibrary => "SDL_VULKAN_LIBRARY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUGraphicsPipelineHandle ISdl.CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ) => + ( + (delegate* unmanaged< + GPUDeviceHandle, + GPUGraphicsPipelineCreateInfo*, + GPUGraphicsPipelineHandle>)( + _slots[110] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[110] = nativeContext.LoadFunction( + "SDL_CreateGPUGraphicsPipeline", + "SDL3" + ) + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_WAVE_FACT_CHUNK \"SDL_WAVE_FACT_CHUNK\"")] - public static Utf8String HintWaveFactChunk => "SDL_WAVE_FACT_CHUNK"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + GPUGraphicsPipelineCreateInfo* createinfo + ) => DllImport.CreateGPUGraphicsPipeline(device, createinfo); - [NativeTypeName("#define SDL_HINT_WAVE_CHUNK_LIMIT \"SDL_WAVE_CHUNK_LIMIT\"")] - public static Utf8String HintWaveChunkLimit => "SDL_WAVE_CHUNK_LIMIT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUGraphicsPipelineHandle ISdl.CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUGraphicsPipelineCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUGraphicsPipelineHandle) + ((ISdl)this).CreateGPUGraphicsPipeline(device, __dsl_createinfo); + } + } - [NativeTypeName("#define SDL_HINT_WAVE_RIFF_CHUNK_SIZE \"SDL_WAVE_RIFF_CHUNK_SIZE\"")] - public static Utf8String HintWaveRiffChunkSize => "SDL_WAVE_RIFF_CHUNK_SIZE"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUGraphicsPipeline")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUGraphicsPipelineHandle CreateGPUGraphicsPipeline( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUGraphicsPipelineCreateInfo *")] + Ref createinfo + ) => DllImport.CreateGPUGraphicsPipeline(device, createinfo); - [NativeTypeName("#define SDL_HINT_WAVE_TRUNCATION \"SDL_WAVE_TRUNCATION\"")] - public static Utf8String HintWaveTruncation => "SDL_WAVE_TRUNCATION"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUSamplerHandle ISdl.CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ) => + ( + (delegate* unmanaged)( + _slots[111] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[111] = nativeContext.LoadFunction("SDL_CreateGPUSampler", "SDL3") + ) + )(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOW_ACTIVATE_WHEN_RAISED \"SDL_WINDOW_ACTIVATE_WHEN_RAISED\"" - )] - public static Utf8String HintWindowActivateWhenRaised => "SDL_WINDOW_ACTIVATE_WHEN_RAISED"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] GPUSamplerCreateInfo* createinfo + ) => DllImport.CreateGPUSampler(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOW_ACTIVATE_WHEN_SHOWN \"SDL_WINDOW_ACTIVATE_WHEN_SHOWN\"" - )] - public static Utf8String HintWindowActivateWhenShown => "SDL_WINDOW_ACTIVATE_WHEN_SHOWN"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUSamplerHandle ISdl.CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] Ref createinfo + ) + { + fixed (GPUSamplerCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUSamplerHandle)((ISdl)this).CreateGPUSampler(device, __dsl_createinfo); + } + } - [NativeTypeName("#define SDL_HINT_WINDOW_ALLOW_TOPMOST \"SDL_WINDOW_ALLOW_TOPMOST\"")] - public static Utf8String HintWindowAllowTopmost => "SDL_WINDOW_ALLOW_TOPMOST"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUSampler")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUSamplerHandle CreateGPUSampler( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUSamplerCreateInfo *")] Ref createinfo + ) => DllImport.CreateGPUSampler(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN \"SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN\"" - )] - public static Utf8String HintWindowFrameUsableWhileCursorHidden => - "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUShaderHandle ISdl.CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ) => + ( + (delegate* unmanaged)( + _slots[112] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[112] = nativeContext.LoadFunction("SDL_CreateGPUShader", "SDL3") + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_WINDOWS_CLOSE_ON_ALT_F4 \"SDL_WINDOWS_CLOSE_ON_ALT_F4\"")] - public static Utf8String HintWindowsCloseOnAltF4 => "SDL_WINDOWS_CLOSE_ON_ALT_F4"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] GPUShaderCreateInfo* createinfo + ) => DllImport.CreateGPUShader(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOWS_ENABLE_MENU_MNEMONICS \"SDL_WINDOWS_ENABLE_MENU_MNEMONICS\"" - )] - public static Utf8String HintWindowsEnableMenuMnemonics => - "SDL_WINDOWS_ENABLE_MENU_MNEMONICS"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUShaderHandle ISdl.CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ) + { + fixed (GPUShaderCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUShaderHandle)((ISdl)this).CreateGPUShader(device, __dsl_createinfo); + } + } - [NativeTypeName( - "#define SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP \"SDL_WINDOWS_ENABLE_MESSAGELOOP\"" - )] - public static Utf8String HintWindowsEnableMessageloop => "SDL_WINDOWS_ENABLE_MESSAGELOOP"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUShader")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUShaderHandle CreateGPUShader( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUShaderCreateInfo *")] Ref createinfo + ) => DllImport.CreateGPUShader(device, createinfo); - [NativeTypeName("#define SDL_HINT_WINDOWS_GAMEINPUT \"SDL_WINDOWS_GAMEINPUT\"")] - public static Utf8String HintWindowsGameinput => "SDL_WINDOWS_GAMEINPUT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUTextureHandle ISdl.CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ) => + ( + (delegate* unmanaged)( + _slots[113] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[113] = nativeContext.LoadFunction("SDL_CreateGPUTexture", "SDL3") + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_WINDOWS_RAW_KEYBOARD \"SDL_WINDOWS_RAW_KEYBOARD\"")] - public static Utf8String HintWindowsRawKeyboard => "SDL_WINDOWS_RAW_KEYBOARD"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] GPUTextureCreateInfo* createinfo + ) => DllImport.CreateGPUTexture(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL \"SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL\"" - )] - public static Utf8String HintWindowsForceSemaphoreKernel => - "SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUTextureHandle ISdl.CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] Ref createinfo + ) + { + fixed (GPUTextureCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUTextureHandle)((ISdl)this).CreateGPUTexture(device, __dsl_createinfo); + } + } - [NativeTypeName("#define SDL_HINT_WINDOWS_INTRESOURCE_ICON \"SDL_WINDOWS_INTRESOURCE_ICON\"")] - public static Utf8String HintWindowsIntresourceIcon => "SDL_WINDOWS_INTRESOURCE_ICON"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUTextureHandle CreateGPUTexture( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTextureCreateInfo *")] Ref createinfo + ) => DllImport.CreateGPUTexture(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL \"SDL_WINDOWS_INTRESOURCE_ICON_SMALL\"" - )] - public static Utf8String HintWindowsIntresourceIconSmall => - "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUTransferBufferHandle ISdl.CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ) => + ( + (delegate* unmanaged< + GPUDeviceHandle, + GPUTransferBufferCreateInfo*, + GPUTransferBufferHandle>)( + _slots[114] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[114] = nativeContext.LoadFunction( + "SDL_CreateGPUTransferBuffer", + "SDL3" + ) + ) + )(device, createinfo); - [NativeTypeName("#define SDL_HINT_WINDOWS_USE_D3D9EX \"SDL_WINDOWS_USE_D3D9EX\"")] - public static Utf8String HintWindowsUseD3D9Ex => "SDL_WINDOWS_USE_D3D9EX"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + GPUTransferBufferCreateInfo* createinfo + ) => DllImport.CreateGPUTransferBuffer(device, createinfo); - [NativeTypeName( - "#define SDL_HINT_WINDOWS_ERASE_BACKGROUND_MODE \"SDL_WINDOWS_ERASE_BACKGROUND_MODE\"" - )] - public static Utf8String HintWindowsEraseBackgroundMode => - "SDL_WINDOWS_ERASE_BACKGROUND_MODE"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GPUTransferBufferHandle ISdl.CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ) + { + fixed (GPUTransferBufferCreateInfo* __dsl_createinfo = createinfo) + { + return (GPUTransferBufferHandle) + ((ISdl)this).CreateGPUTransferBuffer(device, __dsl_createinfo); + } + } - [NativeTypeName( - "#define SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT \"SDL_X11_FORCE_OVERRIDE_REDIRECT\"" - )] - public static Utf8String HintX11ForceOverrideRedirect => "SDL_X11_FORCE_OVERRIDE_REDIRECT"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateGPUTransferBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static GPUTransferBufferHandle CreateGPUTransferBuffer( + GPUDeviceHandle device, + [NativeTypeName("const SDL_GPUTransferBufferCreateInfo *")] + Ref createinfo + ) => DllImport.CreateGPUTransferBuffer(device, createinfo); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => + ( + (delegate* unmanaged)( + _slots[115] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[115] = nativeContext.LoadFunction("SDL_CreateHapticEffect", "SDL3") + ) + )(haptic, effect); - [NativeTypeName("#define SDL_HINT_X11_WINDOW_TYPE \"SDL_X11_WINDOW_TYPE\"")] - public static Utf8String HintX11WindowType => "SDL_X11_WINDOW_TYPE"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => DllImport.CreateHapticEffect(haptic, effect); - [NativeTypeName("#define SDL_HINT_X11_XCB_LIBRARY \"SDL_X11_XCB_LIBRARY\"")] - public static Utf8String HintX11XcbLibrary => "SDL_X11_XCB_LIBRARY"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) + { + fixed (HapticEffect* __dsl_effect = effect) + { + return (int)((ISdl)this).CreateHapticEffect(haptic, __dsl_effect); + } + } - [NativeTypeName("#define SDL_HINT_XINPUT_ENABLED \"SDL_XINPUT_ENABLED\"")] - public static Utf8String HintXinputEnabled => "SDL_XINPUT_ENABLED"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int CreateHapticEffect( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) => DllImport.CreateHapticEffect(haptic, effect); - [NativeTypeName("#define SDL_HINT_ASSERT \"SDL_ASSERT\"")] - public static Utf8String HintAssert => "SDL_ASSERT"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MutexHandle ISdl.CreateMutex() => + ( + (delegate* unmanaged)( + _slots[116] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[116] = nativeContext.LoadFunction("SDL_CreateMutex", "SDL3") + ) + )(); - [NativeTypeName("#define SDL_INIT_AUDIO 0x00000010u")] - public const uint InitAudio = 0x00000010U; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MutexHandle CreateMutex() => DllImport.CreateMutex(); - [NativeTypeName("#define SDL_INIT_VIDEO 0x00000020u")] - public const uint InitVideo = 0x00000020U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreatePalette(int ncolors) => + (Palette*)((ISdl)this).CreatePaletteRaw(ncolors); - [NativeTypeName("#define SDL_INIT_JOYSTICK 0x00000200u")] - public const uint InitJoystick = 0x00000200U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreatePalette(int ncolors) => DllImport.CreatePalette(ncolors); - [NativeTypeName("#define SDL_INIT_HAPTIC 0x00001000u")] - public const uint InitHaptic = 0x00001000U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Palette* ISdl.CreatePaletteRaw(int ncolors) => + ( + (delegate* unmanaged)( + _slots[117] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[117] = nativeContext.LoadFunction("SDL_CreatePalette", "SDL3") + ) + )(ncolors); - [NativeTypeName("#define SDL_INIT_GAMEPAD 0x00002000u")] - public const uint InitGamepad = 0x00002000U; + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Palette* CreatePaletteRaw(int ncolors) => DllImport.CreatePaletteRaw(ncolors); - [NativeTypeName("#define SDL_INIT_EVENTS 0x00004000u")] - public const uint InitEvents = 0x00004000U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.CreatePopupWindow( + WindowHandle parent, + int offset_x, + int offset_y, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => + ( + (delegate* unmanaged)( + _slots[118] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[118] = nativeContext.LoadFunction("SDL_CreatePopupWindow", "SDL3") + ) + )(parent, offset_x, offset_y, w, h, flags); - [NativeTypeName("#define SDL_INIT_SENSOR 0x00008000u")] - public const uint InitSensor = 0x00008000U; + [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle CreatePopupWindow( + WindowHandle parent, + int offset_x, + int offset_y, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => DllImport.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); - [NativeTypeName("#define SDL_INIT_CAMERA 0x00010000u")] - public const uint InitCamera = 0x00010000U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ProcessHandle ISdl.CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ) => + ( + (delegate* unmanaged)( + _slots[119] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[119] = nativeContext.LoadFunction("SDL_CreateProcess", "SDL3") + ) + )(args, pipe_stdio); - [NativeTypeName("#define SDL_PROP_APP_METADATA_NAME_STRING \"SDL.app.metadata.name\"")] - public static Utf8String PropAppMetadataNameString => "SDL.app.metadata.name"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] sbyte** args, + [NativeTypeName("bool")] byte pipe_stdio + ) => DllImport.CreateProcess(args, pipe_stdio); - [NativeTypeName("#define SDL_PROP_APP_METADATA_VERSION_STRING \"SDL.app.metadata.version\"")] - public static Utf8String PropAppMetadataVersionString => "SDL.app.metadata.version"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ProcessHandle ISdl.CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ) + { + fixed (sbyte** __dsl_args = args) + { + return (ProcessHandle)((ISdl)this).CreateProcess(__dsl_args, (byte)pipe_stdio); + } + } - [NativeTypeName( - "#define SDL_PROP_APP_METADATA_IDENTIFIER_STRING \"SDL.app.metadata.identifier\"" - )] - public static Utf8String PropAppMetadataIdentifierString => "SDL.app.metadata.identifier"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcess")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ProcessHandle CreateProcess( + [NativeTypeName("const char *const *")] Ref2D args, + [NativeTypeName("bool")] MaybeBool pipe_stdio + ) => DllImport.CreateProcess(args, pipe_stdio); - [NativeTypeName("#define SDL_PROP_APP_METADATA_CREATOR_STRING \"SDL.app.metadata.creator\"")] - public static Utf8String PropAppMetadataCreatorString => "SDL.app.metadata.creator"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ProcessHandle ISdl.CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[120] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[120] = nativeContext.LoadFunction( + "SDL_CreateProcessWithProperties", + "SDL3" + ) + ) + )(props); - [NativeTypeName( - "#define SDL_PROP_APP_METADATA_COPYRIGHT_STRING \"SDL.app.metadata.copyright\"" - )] - public static Utf8String PropAppMetadataCopyrightString => "SDL.app.metadata.copyright"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProcessWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ProcessHandle CreateProcessWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateProcessWithProperties(props); - [NativeTypeName("#define SDL_PROP_APP_METADATA_URL_STRING \"SDL.app.metadata.url\"")] - public static Utf8String PropAppMetadataUrlString => "SDL.app.metadata.url"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.CreateProperties() => + ( + (delegate* unmanaged)( + _slots[121] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[121] = nativeContext.LoadFunction("SDL_CreateProperties", "SDL3") + ) + )(); - [NativeTypeName("#define SDL_PROP_APP_METADATA_TYPE_STRING \"SDL.app.metadata.type\"")] - public static Utf8String PropAppMetadataTypeString => "SDL.app.metadata.type"u8; + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint CreateProperties() => DllImport.CreateProperties(); - [NativeTypeName("#define SDL_MESSAGEBOX_ERROR 0x00000010u")] - public const uint MessageboxError = 0x00000010U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RendererHandle ISdl.CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] sbyte* name + ) => + ( + (delegate* unmanaged)( + _slots[122] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[122] = nativeContext.LoadFunction("SDL_CreateRenderer", "SDL3") + ) + )(window, name); - [NativeTypeName("#define SDL_MESSAGEBOX_WARNING 0x00000020u")] - public const uint MessageboxWarning = 0x00000020U; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RendererHandle CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.CreateRenderer(window, name); - [NativeTypeName("#define SDL_MESSAGEBOX_INFORMATION 0x00000040u")] - public const uint MessageboxInformation = 0x00000040U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RendererHandle ISdl.CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (RendererHandle)((ISdl)this).CreateRenderer(window, __dsl_name); + } + } - [NativeTypeName("#define SDL_MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT 0x00000080u")] - public const uint MessageboxButtonsLeftToRight = 0x00000080U; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RendererHandle CreateRenderer( + WindowHandle window, + [NativeTypeName("const char *")] Ref name + ) => DllImport.CreateRenderer(window, name); - [NativeTypeName("#define SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT 0x00000100u")] - public const uint MessageboxButtonsRightToLeft = 0x00000100U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RendererHandle ISdl.CreateRendererWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[123] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[123] = nativeContext.LoadFunction( + "SDL_CreateRendererWithProperties", + "SDL3" + ) + ) + )(props); - [NativeTypeName("#define SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT 0x00000001u")] - public const uint MessageboxButtonReturnkeyDefault = 0x00000001U; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RendererHandle CreateRendererWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateRendererWithProperties(props); - [NativeTypeName("#define SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT 0x00000002u")] - public const uint MessageboxButtonEscapekeyDefault = 0x00000002U; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RWLockHandle ISdl.CreateRWLock() => + ( + (delegate* unmanaged)( + _slots[124] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[124] = nativeContext.LoadFunction("SDL_CreateRWLock", "SDL3") + ) + )(); - [NativeTypeName("#define SDL_SOFTWARE_RENDERER \"software\"")] - public static Utf8String SoftwareRenderer => "software"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RWLockHandle CreateRWLock() => DllImport.CreateRWLock(); - [NativeTypeName("#define SDL_PROP_RENDERER_CREATE_NAME_STRING \"SDL.renderer.create.name\"")] - public static Utf8String PropRendererCreateNameString => "SDL.renderer.create.name"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + SemaphoreHandle ISdl.CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => + ( + (delegate* unmanaged)( + _slots[125] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[125] = nativeContext.LoadFunction("SDL_CreateSemaphore", "SDL3") + ) + )(initial_value); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_WINDOW_POINTER \"SDL.renderer.create.window\"" - )] - public static Utf8String PropRendererCreateWindowPointer => "SDL.renderer.create.window"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static SemaphoreHandle CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => + DllImport.CreateSemaphore(initial_value); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_SURFACE_POINTER \"SDL.renderer.create.surface\"" - )] - public static Utf8String PropRendererCreateSurfacePointer => "SDL.renderer.create.surface"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RendererHandle ISdl.CreateSoftwareRenderer(Surface* surface) => + ( + (delegate* unmanaged)( + _slots[126] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[126] = nativeContext.LoadFunction("SDL_CreateSoftwareRenderer", "SDL3") + ) + )(surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER \"SDL.renderer.create.output_colorspace\"" - )] - public static Utf8String PropRendererCreateOutputColorspaceNumber => - "SDL.renderer.create.output_colorspace"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RendererHandle CreateSoftwareRenderer(Surface* surface) => + DllImport.CreateSoftwareRenderer(surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER \"SDL.renderer.create.present_vsync\"" - )] - public static Utf8String PropRendererCreatePresentVsyncNumber => - "SDL.renderer.create.present_vsync"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + RendererHandle ISdl.CreateSoftwareRenderer(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (RendererHandle)((ISdl)this).CreateSoftwareRenderer(__dsl_surface); + } + } - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER \"SDL.renderer.create.vulkan.instance\"" - )] - public static Utf8String PropRendererCreateVulkanInstancePointer => - "SDL.renderer.create.vulkan.instance"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static RendererHandle CreateSoftwareRenderer(Ref surface) => + DllImport.CreateSoftwareRenderer(surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER \"SDL.renderer.create.vulkan.surface\"" - )] - public static Utf8String PropRendererCreateVulkanSurfaceNumber => - "SDL.renderer.create.vulkan.surface"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => + ( + (delegate* unmanaged)( + _slots[127] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[127] = nativeContext.LoadFunction("SDL_CreateStorageDirectory", "SDL3") + ) + )(storage, path); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER \"SDL.renderer.create.vulkan.physical_device\"" - )] - public static Utf8String PropRendererCreateVulkanPhysicalDevicePointer => - "SDL.renderer.create.vulkan.physical_device"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => DllImport.CreateStorageDirectory(storage, path); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER \"SDL.renderer.create.vulkan.device\"" - )] - public static Utf8String PropRendererCreateVulkanDevicePointer => - "SDL.renderer.create.vulkan.device"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).CreateStorageDirectory(storage, __dsl_path); + } + } - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.create.vulkan.graphics_queue_family_index\"" - )] - public static Utf8String PropRendererCreateVulkanGraphicsQueueFamilyIndexNumber => - "SDL.renderer.create.vulkan.graphics_queue_family_index"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CreateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) => DllImport.CreateStorageDirectory(storage, path); - [NativeTypeName( - "#define SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.create.vulkan.present_queue_family_index\"" - )] - public static Utf8String PropRendererCreateVulkanPresentQueueFamilyIndexNumber => - "SDL.renderer.create.vulkan.present_queue_family_index"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateSurface(int width, int height, PixelFormat format) => + (Surface*)((ISdl)this).CreateSurfaceRaw(width, height, format); - [NativeTypeName("#define SDL_PROP_RENDERER_NAME_STRING \"SDL.renderer.name\"")] - public static Utf8String PropRendererNameString => "SDL.renderer.name"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateSurface(int width, int height, PixelFormat format) => + DllImport.CreateSurface(width, height, format); - [NativeTypeName("#define SDL_PROP_RENDERER_WINDOW_POINTER \"SDL.renderer.window\"")] - public static Utf8String PropRendererWindowPointer => "SDL.renderer.window"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + void* pixels, + int pitch + ) => + ( + (delegate* unmanaged)( + _slots[129] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[129] = nativeContext.LoadFunction("SDL_CreateSurfaceFrom", "SDL3") + ) + )(width, height, format, pixels, pitch); - [NativeTypeName("#define SDL_PROP_RENDERER_SURFACE_POINTER \"SDL.renderer.surface\"")] - public static Utf8String PropRendererSurfacePointer => "SDL.renderer.surface"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + void* pixels, + int pitch + ) => DllImport.CreateSurfaceFrom(width, height, format, pixels, pitch); - [NativeTypeName("#define SDL_PROP_RENDERER_VSYNC_NUMBER \"SDL.renderer.vsync\"")] - public static Utf8String PropRendererVsyncNumber => "SDL.renderer.vsync"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + Ref pixels, + int pitch + ) + { + fixed (void* __dsl_pixels = pixels) + { + return (Surface*) + ((ISdl)this).CreateSurfaceFrom(width, height, format, __dsl_pixels, pitch); + } + } - [NativeTypeName( - "#define SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER \"SDL.renderer.max_texture_size\"" - )] - public static Utf8String PropRendererMaxTextureSizeNumber => "SDL.renderer.max_texture_size"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateSurfaceFrom( + int width, + int height, + PixelFormat format, + Ref pixels, + int pitch + ) => DllImport.CreateSurfaceFrom(width, height, format, pixels, pitch); - [NativeTypeName( - "#define SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER \"SDL.renderer.texture_formats\"" - )] - public static Utf8String PropRendererTextureFormatsPointer => "SDL.renderer.texture_formats"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Palette* ISdl.CreateSurfacePalette(Surface* surface) => + ( + (delegate* unmanaged)( + _slots[130] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[130] = nativeContext.LoadFunction("SDL_CreateSurfacePalette", "SDL3") + ) + )(surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER \"SDL.renderer.output_colorspace\"" - )] - public static Utf8String PropRendererOutputColorspaceNumber => - "SDL.renderer.output_colorspace"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Palette* CreateSurfacePalette(Surface* surface) => + DllImport.CreateSurfacePalette(surface); - [NativeTypeName("#define SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN \"SDL.renderer.HDR_enabled\"")] - public static Utf8String PropRendererHdrEnabledBoolean => "SDL.renderer.HDR_enabled"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateSurfacePalette(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Palette*)((ISdl)this).CreateSurfacePalette(__dsl_surface); + } + } - [NativeTypeName( - "#define SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT \"SDL.renderer.SDR_white_point\"" - )] - public static Utf8String PropRendererSdrWhitePointFloat => "SDL.renderer.SDR_white_point"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateSurfacePalette(Ref surface) => + DllImport.CreateSurfacePalette(surface); - [NativeTypeName("#define SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT \"SDL.renderer.HDR_headroom\"")] - public static Utf8String PropRendererHdrHeadroomFloat => "SDL.renderer.HDR_headroom"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.CreateSurfaceRaw(int width, int height, PixelFormat format) => + ( + (delegate* unmanaged)( + _slots[128] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[128] = nativeContext.LoadFunction("SDL_CreateSurface", "SDL3") + ) + )(width, height, format); - [NativeTypeName("#define SDL_PROP_RENDERER_D3D9_DEVICE_POINTER \"SDL.renderer.d3d9.device\"")] - public static Utf8String PropRendererD3D9DevicePointer => "SDL.renderer.d3d9.device"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => + DllImport.CreateSurfaceRaw(width, height, format); - [NativeTypeName("#define SDL_PROP_RENDERER_D3D11_DEVICE_POINTER \"SDL.renderer.d3d11.device\"")] - public static Utf8String PropRendererD3D11DevicePointer => "SDL.renderer.d3d11.device"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + CursorHandle ISdl.CreateSystemCursor(SystemCursor id) => + ( + (delegate* unmanaged)( + _slots[131] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[131] = nativeContext.LoadFunction("SDL_CreateSystemCursor", "SDL3") + ) + )(id); - [NativeTypeName( - "#define SDL_PROP_RENDERER_D3D11_SWAPCHAIN_POINTER \"SDL.renderer.d3d11.swap_chain\"" - )] - public static Utf8String PropRendererD3D11SwapchainPointer => "SDL.renderer.d3d11.swap_chain"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static CursorHandle CreateSystemCursor(SystemCursor id) => + DllImport.CreateSystemCursor(id); - [NativeTypeName("#define SDL_PROP_RENDERER_D3D12_DEVICE_POINTER \"SDL.renderer.d3d12.device\"")] - public static Utf8String PropRendererD3D12DevicePointer => "SDL.renderer.d3d12.device"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateTexture( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => (Texture*)((ISdl)this).CreateTextureRaw(renderer, format, access, w, h); - [NativeTypeName( - "#define SDL_PROP_RENDERER_D3D12_SWAPCHAIN_POINTER \"SDL.renderer.d3d12.swap_chain\"" - )] - public static Utf8String PropRendererD3D12SwapchainPointer => "SDL.renderer.d3d12.swap_chain"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateTexture( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => DllImport.CreateTexture(renderer, format, access, w, h); - [NativeTypeName( - "#define SDL_PROP_RENDERER_D3D12_COMMAND_QUEUE_POINTER \"SDL.renderer.d3d12.command_queue\"" - )] - public static Utf8String PropRendererD3D12CommandQueuePointer => - "SDL.renderer.d3d12.command_queue"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Texture* ISdl.CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => + ( + (delegate* unmanaged)( + _slots[133] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[133] = nativeContext.LoadFunction( + "SDL_CreateTextureFromSurface", + "SDL3" + ) + ) + )(renderer, surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_INSTANCE_POINTER \"SDL.renderer.vulkan.instance\"" - )] - public static Utf8String PropRendererVulkanInstancePointer => "SDL.renderer.vulkan.instance"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Texture* CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => + DllImport.CreateTextureFromSurface(renderer, surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_SURFACE_NUMBER \"SDL.renderer.vulkan.surface\"" - )] - public static Utf8String PropRendererVulkanSurfaceNumber => "SDL.renderer.vulkan.surface"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateTextureFromSurface(RendererHandle renderer, Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Texture*)((ISdl)this).CreateTextureFromSurface(renderer, __dsl_surface); + } + } - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_PHYSICAL_DEVICE_POINTER \"SDL.renderer.vulkan.physical_device\"" - )] - public static Utf8String PropRendererVulkanPhysicalDevicePointer => - "SDL.renderer.vulkan.physical_device"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateTextureFromSurface( + RendererHandle renderer, + Ref surface + ) => DllImport.CreateTextureFromSurface(renderer, surface); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_DEVICE_POINTER \"SDL.renderer.vulkan.device\"" - )] - public static Utf8String PropRendererVulkanDevicePointer => "SDL.renderer.vulkan.device"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Texture* ISdl.CreateTextureRaw( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => + ( + (delegate* unmanaged)( + _slots[132] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[132] = nativeContext.LoadFunction("SDL_CreateTexture", "SDL3") + ) + )(renderer, format, access, w, h); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.vulkan.graphics_queue_family_index\"" - )] - public static Utf8String PropRendererVulkanGraphicsQueueFamilyIndexNumber => - "SDL.renderer.vulkan.graphics_queue_family_index"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Texture* CreateTextureRaw( + RendererHandle renderer, + PixelFormat format, + TextureAccess access, + int w, + int h + ) => DllImport.CreateTextureRaw(renderer, format, access, w, h); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER \"SDL.renderer.vulkan.present_queue_family_index\"" - )] - public static Utf8String PropRendererVulkanPresentQueueFamilyIndexNumber => - "SDL.renderer.vulkan.present_queue_family_index"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.CreateTextureWithProperties( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => (Texture*)((ISdl)this).CreateTextureWithPropertiesRaw(renderer, props); - [NativeTypeName( - "#define SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER \"SDL.renderer.vulkan.swapchain_image_count\"" - )] - public static Utf8String PropRendererVulkanSwapchainImageCountNumber => - "SDL.renderer.vulkan.swapchain_image_count"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr CreateTextureWithProperties( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateTextureWithProperties(renderer, props); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER \"SDL.texture.create.colorspace\"" - )] - public static Utf8String PropTextureCreateColorspaceNumber => "SDL.texture.create.colorspace"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Texture* ISdl.CreateTextureWithPropertiesRaw( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[134] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[134] = nativeContext.LoadFunction( + "SDL_CreateTextureWithProperties", + "SDL3" + ) + ) + )(renderer, props); - [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER \"SDL.texture.create.format\"")] - public static Utf8String PropTextureCreateFormatNumber => "SDL.texture.create.format"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Texture* CreateTextureWithPropertiesRaw( + RendererHandle renderer, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateTextureWithPropertiesRaw(renderer, props); - [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER \"SDL.texture.create.access\"")] - public static Utf8String PropTextureCreateAccessNumber => "SDL.texture.create.access"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ThreadHandle ISdl.CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] sbyte* name, + void* data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => + ( + (delegate* unmanaged< + ThreadFunction, + sbyte*, + void*, + FunctionPointer, + FunctionPointer, + ThreadHandle>)( + _slots[135] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[135] = nativeContext.LoadFunction("SDL_CreateThreadRuntime", "SDL3") + ) + )(fn, name, data, pfnBeginThread, pfnEndThread); - [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER \"SDL.texture.create.width\"")] - public static Utf8String PropTextureCreateWidthNumber => "SDL.texture.create.width"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] sbyte* name, + void* data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => DllImport.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); - [NativeTypeName("#define SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER \"SDL.texture.create.height\"")] - public static Utf8String PropTextureCreateHeightNumber => "SDL.texture.create.height"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ThreadHandle ISdl.CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] Ref name, + Ref data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) + { + fixed (void* __dsl_data = data) + fixed (sbyte* __dsl_name = name) + { + return (ThreadHandle) + ((ISdl)this).CreateThreadRuntime( + fn, + __dsl_name, + __dsl_data, + pfnBeginThread, + pfnEndThread + ); + } + } - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT \"SDL.texture.create.SDR_white_point\"" - )] - public static Utf8String PropTextureCreateSdrWhitePointFloat => - "SDL.texture.create.SDR_white_point"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ThreadHandle CreateThreadRuntime( + [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, + [NativeTypeName("const char *")] Ref name, + Ref data, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => DllImport.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT \"SDL.texture.create.HDR_headroom\"" - )] - public static Utf8String PropTextureCreateHdrHeadroomFloat => - "SDL.texture.create.HDR_headroom"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ThreadHandle ISdl.CreateThreadWithPropertiesRuntime( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => + ( + (delegate* unmanaged)( + _slots[136] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[136] = nativeContext.LoadFunction( + "SDL_CreateThreadWithPropertiesRuntime", + "SDL3" + ) + ) + )(props, pfnBeginThread, pfnEndThread); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_POINTER \"SDL.texture.create.d3d11.texture\"" - )] - public static Utf8String PropTextureCreateD3D11TexturePointer => - "SDL.texture.create.d3d11.texture"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ThreadHandle CreateThreadWithPropertiesRuntime( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, + [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + ) => DllImport.CreateThreadWithPropertiesRuntime(props, pfnBeginThread, pfnEndThread); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_U_POINTER \"SDL.texture.create.d3d11.texture_u\"" - )] - public static Utf8String PropTextureCreateD3D11TextureUPointer => - "SDL.texture.create.d3d11.texture_u"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.CreateWindow( + [NativeTypeName("const char *")] sbyte* title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => + ( + (delegate* unmanaged)( + _slots[137] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[137] = nativeContext.LoadFunction("SDL_CreateWindow", "SDL3") + ) + )(title, w, h, flags); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_V_POINTER \"SDL.texture.create.d3d11.texture_v\"" - )] - public static Utf8String PropTextureCreateD3D11TextureVPointer => - "SDL.texture.create.d3d11.texture_v"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle CreateWindow( + [NativeTypeName("const char *")] sbyte* title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => DllImport.CreateWindow(title, w, h, flags); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_POINTER \"SDL.texture.create.d3d12.texture\"" - )] - public static Utf8String PropTextureCreateD3D12TexturePointer => - "SDL.texture.create.d3d12.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.CreateWindow( + [NativeTypeName("const char *")] Ref title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) + { + fixed (sbyte* __dsl_title = title) + { + return (WindowHandle)((ISdl)this).CreateWindow(__dsl_title, w, h, flags); + } + } - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_U_POINTER \"SDL.texture.create.d3d12.texture_u\"" - )] - public static Utf8String PropTextureCreateD3D12TextureUPointer => - "SDL.texture.create.d3d12.texture_u"u8; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle CreateWindow( + [NativeTypeName("const char *")] Ref title, + int w, + int h, + [NativeTypeName("SDL_WindowFlags")] ulong flags + ) => DllImport.CreateWindow(title, w, h, flags); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_V_POINTER \"SDL.texture.create.d3d12.texture_v\"" - )] - public static Utf8String PropTextureCreateD3D12TextureVPointer => - "SDL.texture.create.d3d12.texture_v"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CreateWindowAndRenderer( + [NativeTypeName("const char *")] sbyte* title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + WindowHandle* window, + RendererHandle* renderer + ) => + ( + (delegate* unmanaged)( + _slots[138] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[138] = nativeContext.LoadFunction( + "SDL_CreateWindowAndRenderer", + "SDL3" + ) + ) + )(title, width, height, window_flags, window, renderer); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_METAL_PIXELBUFFER_POINTER \"SDL.texture.create.metal.pixelbuffer\"" - )] - public static Utf8String PropTextureCreateMetalPixelbufferPointer => - "SDL.texture.create.metal.pixelbuffer"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CreateWindowAndRenderer( + [NativeTypeName("const char *")] sbyte* title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + WindowHandle* window, + RendererHandle* renderer + ) => DllImport.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER \"SDL.texture.create.opengl.texture\"" - )] - public static Utf8String PropTextureCreateOpenglTextureNumber => - "SDL.texture.create.opengl.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CreateWindowAndRenderer( + [NativeTypeName("const char *")] Ref title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + Ref window, + Ref renderer + ) + { + fixed (RendererHandle* __dsl_renderer = renderer) + fixed (WindowHandle* __dsl_window = window) + fixed (sbyte* __dsl_title = title) + { + return (MaybeBool) + (byte) + ((ISdl)this).CreateWindowAndRenderer( + __dsl_title, + width, + height, + window_flags, + __dsl_window, + __dsl_renderer + ); + } + } - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER \"SDL.texture.create.opengl.texture_uv\"" - )] - public static Utf8String PropTextureCreateOpenglTextureUvNumber => - "SDL.texture.create.opengl.texture_uv"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CreateWindowAndRenderer( + [NativeTypeName("const char *")] Ref title, + int width, + int height, + [NativeTypeName("SDL_WindowFlags")] ulong window_flags, + Ref window, + Ref renderer + ) => DllImport.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER \"SDL.texture.create.opengl.texture_u\"" - )] - public static Utf8String PropTextureCreateOpenglTextureUNumber => - "SDL.texture.create.opengl.texture_u"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.CreateWindowWithProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + ( + (delegate* unmanaged)( + _slots[139] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[139] = nativeContext.LoadFunction( + "SDL_CreateWindowWithProperties", + "SDL3" + ) + ) + )(props); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER \"SDL.texture.create.opengl.texture_v\"" - )] - public static Utf8String PropTextureCreateOpenglTextureVNumber => - "SDL.texture.create.opengl.texture_v"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle CreateWindowWithProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.CreateWindowWithProperties(props); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER \"SDL.texture.create.opengles2.texture\"" - )] - public static Utf8String PropTextureCreateOpengles2TextureNumber => - "SDL.texture.create.opengles2.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.CursorVisible() => (MaybeBool)(byte)((ISdl)this).CursorVisibleRaw(); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER \"SDL.texture.create.opengles2.texture_uv\"" - )] - public static Utf8String PropTextureCreateOpengles2TextureUvNumber => - "SDL.texture.create.opengles2.texture_uv"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool CursorVisible() => DllImport.CursorVisible(); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER \"SDL.texture.create.opengles2.texture_u\"" - )] - public static Utf8String PropTextureCreateOpengles2TextureUNumber => - "SDL.texture.create.opengles2.texture_u"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.CursorVisibleRaw() => + ( + (delegate* unmanaged)( + _slots[140] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[140] = nativeContext.LoadFunction("SDL_CursorVisible", "SDL3") + ) + )(); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER \"SDL.texture.create.opengles2.texture_v\"" - )] - public static Utf8String PropTextureCreateOpengles2TextureVNumber => - "SDL.texture.create.opengles2.texture_v"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte CursorVisibleRaw() => DllImport.CursorVisibleRaw(); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER \"SDL.texture.create.vulkan.texture\"" - )] - public static Utf8String PropTextureCreateVulkanTextureNumber => - "SDL.texture.create.vulkan.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] DateTime* dt, + [NativeTypeName("SDL_Time *")] long* ticks + ) => + ( + (delegate* unmanaged)( + _slots[141] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[141] = nativeContext.LoadFunction("SDL_DateTimeToTime", "SDL3") + ) + )(dt, ticks); - [NativeTypeName("#define SDL_PROP_TEXTURE_COLORSPACE_NUMBER \"SDL.texture.colorspace\"")] - public static Utf8String PropTextureColorspaceNumber => "SDL.texture.colorspace"u8; + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] DateTime* dt, + [NativeTypeName("SDL_Time *")] long* ticks + ) => DllImport.DateTimeToTime(dt, ticks); - [NativeTypeName("#define SDL_PROP_TEXTURE_FORMAT_NUMBER \"SDL.texture.format\"")] - public static Utf8String PropTextureFormatNumber => "SDL.texture.format"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] Ref dt, + [NativeTypeName("SDL_Time *")] Ref ticks + ) + { + fixed (long* __dsl_ticks = ticks) + fixed (DateTime* __dsl_dt = dt) + { + return (MaybeBool)(byte)((ISdl)this).DateTimeToTime(__dsl_dt, __dsl_ticks); + } + } - [NativeTypeName("#define SDL_PROP_TEXTURE_ACCESS_NUMBER \"SDL.texture.access\"")] - public static Utf8String PropTextureAccessNumber => "SDL.texture.access"u8; + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool DateTimeToTime( + [NativeTypeName("const SDL_DateTime *")] Ref dt, + [NativeTypeName("SDL_Time *")] Ref ticks + ) => DllImport.DateTimeToTime(dt, ticks); - [NativeTypeName("#define SDL_PROP_TEXTURE_WIDTH_NUMBER \"SDL.texture.width\"")] - public static Utf8String PropTextureWidthNumber => "SDL.texture.width"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.Delay([NativeTypeName("Uint32")] uint ms) => + ( + (delegate* unmanaged)( + _slots[142] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[142] = nativeContext.LoadFunction("SDL_Delay", "SDL3") + ) + )(ms); - [NativeTypeName("#define SDL_PROP_TEXTURE_HEIGHT_NUMBER \"SDL.texture.height\"")] - public static Utf8String PropTextureHeightNumber => "SDL.texture.height"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void Delay([NativeTypeName("Uint32")] uint ms) => DllImport.Delay(ms); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_SDR_WHITE_POINT_FLOAT \"SDL.texture.SDR_white_point\"" - )] - public static Utf8String PropTextureSdrWhitePointFloat => "SDL.texture.SDR_white_point"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DelayNS([NativeTypeName("Uint64")] ulong ns) => + ( + (delegate* unmanaged)( + _slots[143] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[143] = nativeContext.LoadFunction("SDL_DelayNS", "SDL3") + ) + )(ns); - [NativeTypeName("#define SDL_PROP_TEXTURE_HDR_HEADROOM_FLOAT \"SDL.texture.HDR_headroom\"")] - public static Utf8String PropTextureHdrHeadroomFloat => "SDL.texture.HDR_headroom"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DelayNS([NativeTypeName("Uint64")] ulong ns) => DllImport.DelayNS(ns); - [NativeTypeName("#define SDL_PROP_TEXTURE_D3D11_TEXTURE_POINTER \"SDL.texture.d3d11.texture\"")] - public static Utf8String PropTextureD3D11TexturePointer => "SDL.texture.d3d11.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DelayPrecise([NativeTypeName("Uint64")] ulong ns) => + ( + (delegate* unmanaged)( + _slots[144] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[144] = nativeContext.LoadFunction("SDL_DelayPrecise", "SDL3") + ) + )(ns); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_D3D11_TEXTURE_U_POINTER \"SDL.texture.d3d11.texture_u\"" - )] - public static Utf8String PropTextureD3D11TextureUPointer => "SDL.texture.d3d11.texture_u"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => + DllImport.DelayPrecise(ns); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_D3D11_TEXTURE_V_POINTER \"SDL.texture.d3d11.texture_v\"" - )] - public static Utf8String PropTextureD3D11TextureVPointer => "SDL.texture.d3d11.texture_v"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyAudioStream(AudioStreamHandle stream) => + ( + (delegate* unmanaged)( + _slots[145] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[145] = nativeContext.LoadFunction("SDL_DestroyAudioStream", "SDL3") + ) + )(stream); - [NativeTypeName("#define SDL_PROP_TEXTURE_D3D12_TEXTURE_POINTER \"SDL.texture.d3d12.texture\"")] - public static Utf8String PropTextureD3D12TexturePointer => "SDL.texture.d3d12.texture"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyAudioStream(AudioStreamHandle stream) => + DllImport.DestroyAudioStream(stream); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_D3D12_TEXTURE_U_POINTER \"SDL.texture.d3d12.texture_u\"" - )] - public static Utf8String PropTextureD3D12TextureUPointer => "SDL.texture.d3d12.texture_u"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyCondition(ConditionHandle cond) => + ( + (delegate* unmanaged)( + _slots[146] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[146] = nativeContext.LoadFunction("SDL_DestroyCondition", "SDL3") + ) + )(cond); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_D3D12_TEXTURE_V_POINTER \"SDL.texture.d3d12.texture_v\"" - )] - public static Utf8String PropTextureD3D12TextureVPointer => "SDL.texture.d3d12.texture_v"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyCondition(ConditionHandle cond) => DllImport.DestroyCondition(cond); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER \"SDL.texture.opengl.texture\"" - )] - public static Utf8String PropTextureOpenglTextureNumber => "SDL.texture.opengl.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyCursor(CursorHandle cursor) => + ( + (delegate* unmanaged)( + _slots[147] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[147] = nativeContext.LoadFunction("SDL_DestroyCursor", "SDL3") + ) + )(cursor); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_UV_NUMBER \"SDL.texture.opengl.texture_uv\"" - )] - public static Utf8String PropTextureOpenglTextureUvNumber => "SDL.texture.opengl.texture_uv"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyCursor(CursorHandle cursor) => DllImport.DestroyCursor(cursor); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_U_NUMBER \"SDL.texture.opengl.texture_u\"" - )] - public static Utf8String PropTextureOpenglTextureUNumber => "SDL.texture.opengl.texture_u"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyEnvironment(EnvironmentHandle env) => + ( + (delegate* unmanaged)( + _slots[148] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[148] = nativeContext.LoadFunction("SDL_DestroyEnvironment", "SDL3") + ) + )(env); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_V_NUMBER \"SDL.texture.opengl.texture_v\"" - )] - public static Utf8String PropTextureOpenglTextureVNumber => "SDL.texture.opengl.texture_v"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyEnvironment")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyEnvironment(EnvironmentHandle env) => + DllImport.DestroyEnvironment(env); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER \"SDL.texture.opengl.target\"" - )] - public static Utf8String PropTextureOpenglTextureTargetNumber => "SDL.texture.opengl.target"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyGPUDevice(GPUDeviceHandle device) => + ( + (delegate* unmanaged)( + _slots[149] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[149] = nativeContext.LoadFunction("SDL_DestroyGPUDevice", "SDL3") + ) + )(device); - [NativeTypeName("#define SDL_PROP_TEXTURE_OPENGL_TEX_W_FLOAT \"SDL.texture.opengl.tex_w\"")] - public static Utf8String PropTextureOpenglTexWFloat => "SDL.texture.opengl.tex_w"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyGPUDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyGPUDevice(GPUDeviceHandle device) => + DllImport.DestroyGPUDevice(device); - [NativeTypeName("#define SDL_PROP_TEXTURE_OPENGL_TEX_H_FLOAT \"SDL.texture.opengl.tex_h\"")] - public static Utf8String PropTextureOpenglTexHFloat => "SDL.texture.opengl.tex_h"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyHapticEffect(HapticHandle haptic, int effect) => + ( + (delegate* unmanaged)( + _slots[150] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[150] = nativeContext.LoadFunction("SDL_DestroyHapticEffect", "SDL3") + ) + )(haptic, effect); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_NUMBER \"SDL.texture.opengles2.texture\"" - )] - public static Utf8String PropTextureOpengles2TextureNumber => "SDL.texture.opengles2.texture"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyHapticEffect(HapticHandle haptic, int effect) => + DllImport.DestroyHapticEffect(haptic, effect); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_UV_NUMBER \"SDL.texture.opengles2.texture_uv\"" - )] - public static Utf8String PropTextureOpengles2TextureUvNumber => - "SDL.texture.opengles2.texture_uv"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyMutex(MutexHandle mutex) => + ( + (delegate* unmanaged)( + _slots[151] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[151] = nativeContext.LoadFunction("SDL_DestroyMutex", "SDL3") + ) + )(mutex); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_U_NUMBER \"SDL.texture.opengles2.texture_u\"" - )] - public static Utf8String PropTextureOpengles2TextureUNumber => - "SDL.texture.opengles2.texture_u"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyMutex(MutexHandle mutex) => DllImport.DestroyMutex(mutex); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_V_NUMBER \"SDL.texture.opengles2.texture_v\"" - )] - public static Utf8String PropTextureOpengles2TextureVNumber => - "SDL.texture.opengles2.texture_v"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyPalette(Palette* palette) => + ( + (delegate* unmanaged)( + _slots[152] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[152] = nativeContext.LoadFunction("SDL_DestroyPalette", "SDL3") + ) + )(palette); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_TARGET_NUMBER \"SDL.texture.opengles2.target\"" - )] - public static Utf8String PropTextureOpengles2TextureTargetNumber => - "SDL.texture.opengles2.target"u8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyPalette(Palette* palette) => DllImport.DestroyPalette(palette); - [NativeTypeName( - "#define SDL_PROP_TEXTURE_VULKAN_TEXTURE_NUMBER \"SDL.texture.vulkan.texture\"" - )] - public static Utf8String PropTextureVulkanTextureNumber => "SDL.texture.vulkan.texture"u8; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyPalette(Ref palette) + { + fixed (Palette* __dsl_palette = palette) + { + ((ISdl)this).DestroyPalette(__dsl_palette); + } + } - [NativeTypeName("#define SDL_RENDERER_VSYNC_DISABLED 0")] - public const int RendererVsyncDisabled = 0; + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyPalette(Ref palette) => DllImport.DestroyPalette(palette); - [NativeTypeName("#define SDL_RENDERER_VSYNC_ADAPTIVE (-1)")] - public const int RendererVsyncAdaptive = (-1); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyProcess(ProcessHandle process) => + ( + (delegate* unmanaged)( + _slots[153] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[153] = nativeContext.LoadFunction("SDL_DestroyProcess", "SDL3") + ) + )(process); - [NativeTypeName("#define SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE 8")] - public const int DebugTextFontCharacterSize = 8; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProcess")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyProcess(ProcessHandle process) => DllImport.DestroyProcess(process); - [NativeTypeName("#define SDL_MS_PER_SECOND 1000")] - public const int MsPerSecond = 1000; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + ( + (delegate* unmanaged)( + _slots[154] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[154] = nativeContext.LoadFunction("SDL_DestroyProperties", "SDL3") + ) + )(props); - [NativeTypeName("#define SDL_US_PER_SECOND 1000000")] - public const int UsPerSecond = 1000000; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + DllImport.DestroyProperties(props); - [NativeTypeName("#define SDL_NS_PER_SECOND 1000000000LL")] - public const long NsPerSecond = 1000000000L; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyRenderer(RendererHandle renderer) => + ( + (delegate* unmanaged)( + _slots[155] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[155] = nativeContext.LoadFunction("SDL_DestroyRenderer", "SDL3") + ) + )(renderer); - [NativeTypeName("#define SDL_NS_PER_MS 1000000")] - public const int NsPerMs = 1000000; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyRenderer(RendererHandle renderer) => + DllImport.DestroyRenderer(renderer); - [NativeTypeName("#define SDL_NS_PER_US 1000")] - public const int NsPerUs = 1000; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyRWLock(RWLockHandle rwlock) => + ( + (delegate* unmanaged)( + _slots[156] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[156] = nativeContext.LoadFunction("SDL_DestroyRWLock", "SDL3") + ) + )(rwlock); - [NativeTypeName("#define SDL_MAJOR_VERSION 3")] - public const int MajorVersion = 3; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyRWLock(RWLockHandle rwlock) => DllImport.DestroyRWLock(rwlock); - [NativeTypeName("#define SDL_MINOR_VERSION 1")] - public const int MinorVersion = 1; + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroySemaphore(SemaphoreHandle sem) => + ( + (delegate* unmanaged)( + _slots[157] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[157] = nativeContext.LoadFunction("SDL_DestroySemaphore", "SDL3") + ) + )(sem); - [NativeTypeName("#define SDL_MICRO_VERSION 6")] - public const int MicroVersion = 6; + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroySemaphore(SemaphoreHandle sem) => DllImport.DestroySemaphore(sem); - [NativeTypeName( - "#define SDL_VERSION SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_MICRO_VERSION)" - )] - public const int Version = ((3) * 1000000 + (1) * 1000 + (6)); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroySurface(Surface* surface) => + ( + (delegate* unmanaged)( + _slots[158] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[158] = nativeContext.LoadFunction("SDL_DestroySurface", "SDL3") + ) + )(surface); - public static bool PointInRect( - [NativeTypeName("const SDL_Point *")] Point* p, - [NativeTypeName("const SDL_Rect *")] Rect* r - ) - { - return ( - (p) != null - && (r) != null - && (p->X >= r->X) - && (p->X < (r->X + r->W)) - && (p->Y >= r->Y) - && (p->Y < (r->Y + r->H)) - ) - ? true - : false; - } + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroySurface(Surface* surface) => DllImport.DestroySurface(surface); - [Transformed] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool PointInRect( - [NativeTypeName("const SDL_Point *")] Ref p, - [NativeTypeName("const SDL_Rect *")] Ref r - ) + void ISdl.DestroySurface(Ref surface) { - fixed (Rect* __dsl_r = r) - fixed (Point* __dsl_p = p) + fixed (Surface* __dsl_surface = surface) { - return (bool)PointInRect(__dsl_p, __dsl_r); + ((ISdl)this).DestroySurface(__dsl_surface); } } - public static bool PointInRectFloat( - [NativeTypeName("const SDL_FPoint *")] FPoint* p, - [NativeTypeName("const SDL_FRect *")] FRect* r - ) - { - return ( - (p) != null - && (r) != null - && (p->X >= r->X) - && (p->X <= (r->X + r->W)) - && (p->Y >= r->Y) - && (p->Y <= (r->Y + r->H)) - ) - ? true - : false; - } - [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool PointInRectFloat( - [NativeTypeName("const SDL_FPoint *")] Ref p, - [NativeTypeName("const SDL_FRect *")] Ref r - ) + public static void DestroySurface(Ref surface) => DllImport.DestroySurface(surface); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyTexture(Texture* texture) => + ( + (delegate* unmanaged)( + _slots[159] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[159] = nativeContext.LoadFunction("SDL_DestroyTexture", "SDL3") + ) + )(texture); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyTexture(Texture* texture) => DllImport.DestroyTexture(texture); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyTexture(Ref texture) { - fixed (FRect* __dsl_r = r) - fixed (FPoint* __dsl_p = p) + fixed (Texture* __dsl_texture = texture) { - return (bool)PointInRectFloat(__dsl_p, __dsl_r); + ((ISdl)this).DestroyTexture(__dsl_texture); } } - public static bool RectEmpty([NativeTypeName("const SDL_Rect *")] Rect* r) - { - return ((r == null) || (r->W <= 0) || (r->H <= 0)) ? true : false; - } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyTexture(Ref texture) => DllImport.DestroyTexture(texture); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DestroyWindow(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[160] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[160] = nativeContext.LoadFunction("SDL_DestroyWindow", "SDL3") + ) + )(window); + + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DestroyWindow(WindowHandle window) => DllImport.DestroyWindow(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.DestroyWindowSurface(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).DestroyWindowSurfaceRaw(window); + [return: NativeTypeName("bool")] [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool RectEmpty([NativeTypeName("const SDL_Rect *")] Ref r) - { - fixed (Rect* __dsl_r = r) - { - return (bool)RectEmpty(__dsl_r); - } - } + public static MaybeBool DestroyWindowSurface(WindowHandle window) => + DllImport.DestroyWindowSurface(window); - public static bool RectEmptyFloat([NativeTypeName("const SDL_FRect *")] FRect* r) - { - return ((r == null) || (r->W < 0.0f) || (r->H < 0.0f)) ? true : false; - } + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.DestroyWindowSurfaceRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[161] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[161] = nativeContext.LoadFunction("SDL_DestroyWindowSurface", "SDL3") + ) + )(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte DestroyWindowSurfaceRaw(WindowHandle window) => + DllImport.DestroyWindowSurfaceRaw(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DetachThread(ThreadHandle thread) => + ( + (delegate* unmanaged)( + _slots[162] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[162] = nativeContext.LoadFunction("SDL_DetachThread", "SDL3") + ) + )(thread); + + [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DetachThread(ThreadHandle thread) => DllImport.DetachThread(thread); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.DetachVirtualJoystick( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => (MaybeBool)(byte)((ISdl)this).DetachVirtualJoystickRaw(instance_id); + [return: NativeTypeName("bool")] [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool RectEmptyFloat([NativeTypeName("const SDL_FRect *")] Ref r) - { - fixed (FRect* __dsl_r = r) - { - return (bool)RectEmptyFloat(__dsl_r); - } - } + public static MaybeBool DetachVirtualJoystick( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.DetachVirtualJoystick(instance_id); - public static bool RectsEqual( - [NativeTypeName("const SDL_Rect *")] Rect* a, - [NativeTypeName("const SDL_Rect *")] Rect* b - ) - { - return ( - (a) != null - && (b) != null - && (a->X == b->X) - && (a->Y == b->Y) - && (a->W == b->W) - && (a->H == b->H) - ) - ? true - : false; - } + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.DetachVirtualJoystickRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[163] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[163] = nativeContext.LoadFunction("SDL_DetachVirtualJoystick", "SDL3") + ) + )(instance_id); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte DetachVirtualJoystickRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.DetachVirtualJoystickRaw(instance_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.DisableScreenSaver() => + (MaybeBool)(byte)((ISdl)this).DisableScreenSaverRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool DisableScreenSaver() => DllImport.DisableScreenSaver(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.DisableScreenSaverRaw() => + ( + (delegate* unmanaged)( + _slots[164] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[164] = nativeContext.LoadFunction("SDL_DisableScreenSaver", "SDL3") + ) + )(); - [Transformed] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool RectsEqual( - [NativeTypeName("const SDL_Rect *")] Ref a, - [NativeTypeName("const SDL_Rect *")] Ref b - ) - { - fixed (Rect* __dsl_b = b) - fixed (Rect* __dsl_a = a) - { - return (bool)RectsEqual(__dsl_a, __dsl_b); - } - } + public static byte DisableScreenSaverRaw() => DllImport.DisableScreenSaverRaw(); - public static bool RectsEqualEpsilon( - [NativeTypeName("const SDL_FRect *")] FRect* a, - [NativeTypeName("const SDL_FRect *")] FRect* b, - [NativeTypeName("const float")] float epsilon - ) - { - return ( - (a) != null - && (b) != null - && ( - (a == b) - || ( - (float.Abs(a->X - b->X) <= epsilon) - && (float.Abs(a->Y - b->Y) <= epsilon) - && (float.Abs(a->W - b->W) <= epsilon) - && (float.Abs(a->H - b->H) <= epsilon) - ) + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ) => + ( + (delegate* unmanaged)( + _slots[165] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[165] = nativeContext.LoadFunction("SDL_DispatchGPUCompute", "SDL3") ) - ) - ? true - : false; - } + )(compute_pass, groupcount_x, groupcount_y, groupcount_z); - [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUCompute")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool RectsEqualEpsilon( - [NativeTypeName("const SDL_FRect *")] Ref a, - [NativeTypeName("const SDL_FRect *")] Ref b, - [NativeTypeName("const float")] float epsilon - ) - { - fixed (FRect* __dsl_b = b) - fixed (FRect* __dsl_a = a) - { - return (bool)RectsEqualEpsilon(__dsl_a, __dsl_b, epsilon); - } - } + public static void DispatchGPUCompute( + GPUComputePassHandle compute_pass, + [NativeTypeName("Uint32")] uint groupcount_x, + [NativeTypeName("Uint32")] uint groupcount_y, + [NativeTypeName("Uint32")] uint groupcount_z + ) => DllImport.DispatchGPUCompute(compute_pass, groupcount_x, groupcount_y, groupcount_z); - public static bool RectsEqualFloat( - [NativeTypeName("const SDL_FRect *")] FRect* a, - [NativeTypeName("const SDL_FRect *")] FRect* b - ) - { - return RectsEqualEpsilon(a, b, 1.1920928955078125e-07F); - } + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ) => + ( + (delegate* unmanaged)( + _slots[166] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[166] = nativeContext.LoadFunction( + "SDL_DispatchGPUComputeIndirect", + "SDL3" + ) + ) + )(compute_pass, buffer, offset); - [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DispatchGPUComputeIndirect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool RectsEqualFloat( - [NativeTypeName("const SDL_FRect *")] Ref a, - [NativeTypeName("const SDL_FRect *")] Ref b - ) - { - fixed (FRect* __dsl_b = b) - fixed (FRect* __dsl_a = a) - { - return (bool)RectsEqualFloat(__dsl_a, __dsl_b); - } - } + public static void DispatchGPUComputeIndirect( + GPUComputePassHandle compute_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset + ) => DllImport.DispatchGPUComputeIndirect(compute_pass, buffer, offset); - public static void RectToFRect([NativeTypeName("const SDL_Rect *")] Rect* rect, FRect* frect) - { - frect->X = (float)(rect->X); - frect->Y = (float)(rect->Y); - frect->W = (float)(rect->W); - frect->H = (float)(rect->H); - } + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ) => + ( + (delegate* unmanaged< + GPUCopyPassHandle, + GPUBufferRegion*, + GPUTransferBufferLocation*, + void>)( + _slots[167] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[167] = nativeContext.LoadFunction("SDL_DownloadFromGPUBuffer", "SDL3") + ) + )(copy_pass, source, destination); - [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RectToFRect( - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref frect + public static void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + GPUTransferBufferLocation* destination + ) => DllImport.DownloadFromGPUBuffer(copy_pass, source, destination); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination ) { - fixed (FRect* __dsl_frect = frect) - fixed (Rect* __dsl_rect = rect) + fixed (GPUTransferBufferLocation* __dsl_destination = destination) + fixed (GPUBufferRegion* __dsl_source = source) { - RectToFRect(__dsl_rect, __dsl_frect); + ((ISdl)this).DownloadFromGPUBuffer(copy_pass, __dsl_source, __dsl_destination); } } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] ulong* timestampNS + public static void DownloadFromGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref destination + ) => DllImport.DownloadFromGPUBuffer(copy_pass, source, destination); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* destination ) => ( - (delegate* unmanaged)( - _slots[0] is not null and var loadedFnPtr + (delegate* unmanaged< + GPUCopyPassHandle, + GPUTextureRegion*, + GPUTextureTransferInfo*, + void>)( + _slots[168] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[0] = nativeContext.LoadFunction("SDL_AcquireCameraFrame", "SDL3") + : _slots[168] = nativeContext.LoadFunction("SDL_DownloadFromGPUTexture", "SDL3") ) - )(camera, timestampNS); + )(copy_pass, source, destination); - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] ulong* timestampNS - ) => DllImport.AcquireCameraFrame(camera, timestampNS); + public static void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* destination + ) => DllImport.DownloadFromGPUTexture(copy_pass, source, destination); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] Ref timestampNS + void ISdl.DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination ) { - fixed (ulong* __dsl_timestampNS = timestampNS) + fixed (GPUTextureTransferInfo* __dsl_destination = destination) + fixed (GPUTextureRegion* __dsl_source = source) { - return (Surface*)((ISdl)this).AcquireCameraFrame(camera, __dsl_timestampNS); + ((ISdl)this).DownloadFromGPUTexture(copy_pass, __dsl_source, __dsl_destination); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AcquireCameraFrame")] + [NativeFunction("SDL3", EntryPoint = "SDL_DownloadFromGPUTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr AcquireCameraFrame( - CameraHandle camera, - [NativeTypeName("Uint64 *")] Ref timestampNS - ) => DllImport.AcquireCameraFrame(camera, timestampNS); + public static void DownloadFromGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref source, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] + Ref destination + ) => DllImport.DownloadFromGPUTexture(copy_pass, source, destination); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddAtomicInt(AtomicInt* a, int v) => + void ISdl.DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ) => ( - (delegate* unmanaged)( - _slots[1] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[169] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[1] = nativeContext.LoadFunction("SDL_AddAtomicInt", "SDL3") + : _slots[169] = nativeContext.LoadFunction( + "SDL_DrawGPUIndexedPrimitives", + "SDL3" + ) ) - )(a, v); + )(render_pass, num_indices, num_instances, first_index, vertex_offset, first_instance); - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitives")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddAtomicInt(AtomicInt* a, int v) => DllImport.AddAtomicInt(a, v); + public static void DrawGPUIndexedPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_indices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_index, + [NativeTypeName("Sint32")] int vertex_offset, + [NativeTypeName("Uint32")] uint first_instance + ) => + DllImport.DrawGPUIndexedPrimitives( + render_pass, + num_indices, + num_instances, + first_index, + vertex_offset, + first_instance + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddAtomicInt(Ref a, int v) - { - fixed (AtomicInt* __dsl_a = a) - { - return (int)((ISdl)this).AddAtomicInt(__dsl_a, v); - } - } + void ISdl.DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => + ( + (delegate* unmanaged)( + _slots[170] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[170] = nativeContext.LoadFunction( + "SDL_DrawGPUIndexedPrimitivesIndirect", + "SDL3" + ) + ) + )(render_pass, buffer, offset, draw_count); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUIndexedPrimitivesIndirect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddAtomicInt(Ref a, int v) => DllImport.AddAtomicInt(a, v); + public static void DrawGPUIndexedPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => DllImport.DrawGPUIndexedPrimitivesIndirect(render_pass, buffer, offset, draw_count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata + void ISdl.DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance ) => ( - (delegate* unmanaged)( - _slots[2] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[171] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[2] = nativeContext.LoadFunction("SDL_AddEventWatch", "SDL3") + : _slots[171] = nativeContext.LoadFunction("SDL_DrawGPUPrimitives", "SDL3") ) - )(filter, userdata); + )(render_pass, num_vertices, num_instances, first_vertex, first_instance); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitives")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => DllImport.AddEventWatch(filter, userdata); + public static void DrawGPUPrimitives( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint32")] uint num_vertices, + [NativeTypeName("Uint32")] uint num_instances, + [NativeTypeName("Uint32")] uint first_vertex, + [NativeTypeName("Uint32")] uint first_instance + ) => + DllImport.DrawGPUPrimitives( + render_pass, + num_vertices, + num_instances, + first_vertex, + first_instance + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) + void ISdl.DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => + ( + (delegate* unmanaged)( + _slots[172] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[172] = nativeContext.LoadFunction( + "SDL_DrawGPUPrimitivesIndirect", + "SDL3" + ) + ) + )(render_pass, buffer, offset, draw_count); + + [NativeFunction("SDL3", EntryPoint = "SDL_DrawGPUPrimitivesIndirect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void DrawGPUPrimitivesIndirect( + GPURenderPassHandle render_pass, + GPUBufferHandle buffer, + [NativeTypeName("Uint32")] uint offset, + [NativeTypeName("Uint32")] uint draw_count + ) => DllImport.DrawGPUPrimitivesIndirect(render_pass, buffer, offset, draw_count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Surface* ISdl.DuplicateSurface(Surface* surface) => + ( + (delegate* unmanaged)( + _slots[173] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[173] = nativeContext.LoadFunction("SDL_DuplicateSurface", "SDL3") + ) + )(surface); + + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* DuplicateSurface(Surface* surface) => + DllImport.DuplicateSurface(surface); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.DuplicateSurface(Ref surface) { - fixed (void* __dsl_userdata = userdata) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)((ISdl)this).AddEventWatch(filter, __dsl_userdata); + return (Surface*)((ISdl)this).DuplicateSurface(__dsl_surface); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool AddEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => DllImport.AddEventWatch(filter, userdata); + public static Ptr DuplicateSurface(Ref surface) => + DllImport.DuplicateSurface(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => + Ptr ISdl.EGLGetCurrentConfig() => (void*)((ISdl)this).EGLGetCurrentConfigRaw(); + + [return: NativeTypeName("SDL_EGLConfig")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr EGLGetCurrentConfig() => DllImport.EGLGetCurrentConfig(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.EGLGetCurrentConfigRaw() => ( - (delegate* unmanaged)( - _slots[3] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[174] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[3] = nativeContext.LoadFunction("SDL_AddGamepadMapping", "SDL3") + : _slots[174] = nativeContext.LoadFunction("SDL_EGL_GetCurrentConfig", "SDL3") ) - )(mapping); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [return: NativeTypeName("SDL_EGLConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMapping([NativeTypeName("const char *")] sbyte* mapping) => - DllImport.AddGamepadMapping(mapping); + public static void* EGLGetCurrentConfigRaw() => DllImport.EGLGetCurrentConfigRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) - { - fixed (sbyte* __dsl_mapping = mapping) - { - return (int)((ISdl)this).AddGamepadMapping(__dsl_mapping); - } - } + Ptr ISdl.EGLGetCurrentDisplay() => (void*)((ISdl)this).EGLGetCurrentDisplayRaw(); + [return: NativeTypeName("SDL_EGLDisplay")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMapping([NativeTypeName("const char *")] Ref mapping) => - DllImport.AddGamepadMapping(mapping); + public static Ptr EGLGetCurrentDisplay() => DllImport.EGLGetCurrentDisplay(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => + void* ISdl.EGLGetCurrentDisplayRaw() => ( - (delegate* unmanaged)( - _slots[4] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[175] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[4] = nativeContext.LoadFunction( - "SDL_AddGamepadMappingsFromFile", - "SDL3" - ) + : _slots[175] = nativeContext.LoadFunction("SDL_EGL_GetCurrentDisplay", "SDL3") ) - )(file); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [return: NativeTypeName("SDL_EGLDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMappingsFromFile([NativeTypeName("const char *")] sbyte* file) => - DllImport.AddGamepadMappingsFromFile(file); + public static void* EGLGetCurrentDisplayRaw() => DllImport.EGLGetCurrentDisplayRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMappingsFromFile([NativeTypeName("const char *")] Ref file) + FunctionPointer ISdl.EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + ( + (delegate* unmanaged)( + _slots[176] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[176] = nativeContext.LoadFunction("SDL_EGL_GetProcAddress", "SDL3") + ) + )(proc); + + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static FunctionPointer EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + DllImport.EGLGetProcAddress(proc); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + FunctionPointer ISdl.EGLGetProcAddress([NativeTypeName("const char *")] Ref proc) { - fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_proc = proc) { - return (int)((ISdl)this).AddGamepadMappingsFromFile(__dsl_file); + return (FunctionPointer)((ISdl)this).EGLGetProcAddress(__dsl_proc); } } + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMappingsFromFile( - [NativeTypeName("const char *")] Ref file - ) => DllImport.AddGamepadMappingsFromFile(file); + public static FunctionPointer EGLGetProcAddress( + [NativeTypeName("const char *")] Ref proc + ) => DllImport.EGLGetProcAddress(proc); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMappingsFromIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => - ( - (delegate* unmanaged)( - _slots[5] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[5] = nativeContext.LoadFunction("SDL_AddGamepadMappingsFromIO", "SDL3") - ) - )(src, closeio); + Ptr ISdl.EGLGetWindowSurface(WindowHandle window) => + (void*)((ISdl)this).EGLGetWindowSurfaceRaw(window); - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [return: NativeTypeName("SDL_EGLSurface")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio - ) => DllImport.AddGamepadMappingsFromIO(src, closeio); + public static Ptr EGLGetWindowSurface(WindowHandle window) => + DllImport.EGLGetWindowSurface(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => (int)((ISdl)this).AddGamepadMappingsFromIO(src, (byte)closeio); + void* ISdl.EGLGetWindowSurfaceRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[177] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[177] = nativeContext.LoadFunction("SDL_EGL_GetWindowSurface", "SDL3") + ) + )(window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddGamepadMappingsFromIO")] + [return: NativeTypeName("SDL_EGLSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int AddGamepadMappingsFromIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => DllImport.AddGamepadMappingsFromIO(src, closeio); + public static void* EGLGetWindowSurfaceRaw(WindowHandle window) => + DllImport.EGLGetWindowSurfaceRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.AddHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void ISdl.EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, void* userdata ) => ( - (delegate* unmanaged)( - _slots[6] is not null and var loadedFnPtr + (delegate* unmanaged< + EGLAttribArrayCallback, + EGLIntArrayCallback, + EGLIntArrayCallback, + void*, + void>)( + _slots[178] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[6] = nativeContext.LoadFunction("SDL_AddHintCallback", "SDL3") + : _slots[178] = nativeContext.LoadFunction( + "SDL_EGL_SetAttributeCallbacks", + "SDL3" + ) ) - )(name, callback, userdata); + )(platformAttribCallback, surfaceAttribCallback, contextAttribCallback, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte AddHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, + public static void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, void* userdata - ) => DllImport.AddHintCallback(name, callback, userdata); + ) => + DllImport.EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + userdata + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.AddHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void ISdl.EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, Ref userdata ) { fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_name = name) { - return (MaybeBool) - (byte)((ISdl)this).AddHintCallback(__dsl_name, callback, __dsl_userdata); + ((ISdl)this).EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + __dsl_userdata + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool AddHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, + public static void EGLSetAttributeCallbacks( + [NativeTypeName("SDL_EGLAttribArrayCallback")] + EGLAttribArrayCallback platformAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, + [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, Ref userdata - ) => DllImport.AddHintCallback(name, callback, userdata); + ) => + DllImport.EGLSetAttributeCallbacks( + platformAttribCallback, + surfaceAttribCallback, + contextAttribCallback, + userdata + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.AddSurfaceAlternateImage(Surface* surface, Surface* image) => + MaybeBool ISdl.EnableScreenSaver() => + (MaybeBool)(byte)((ISdl)this).EnableScreenSaverRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool EnableScreenSaver() => DllImport.EnableScreenSaver(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.EnableScreenSaverRaw() => ( - (delegate* unmanaged)( - _slots[7] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[179] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[7] = nativeContext.LoadFunction("SDL_AddSurfaceAlternateImage", "SDL3") + : _slots[179] = nativeContext.LoadFunction("SDL_EnableScreenSaver", "SDL3") ) - )(surface, image); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte AddSurfaceAlternateImage(Surface* surface, Surface* image) => - DllImport.AddSurfaceAlternateImage(surface, image); + public static byte EnableScreenSaverRaw() => DllImport.EnableScreenSaverRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.AddSurfaceAlternateImage(Ref surface, Ref image) + void ISdl.EndGPUComputePass(GPUComputePassHandle compute_pass) => + ( + (delegate* unmanaged)( + _slots[180] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[180] = nativeContext.LoadFunction("SDL_EndGPUComputePass", "SDL3") + ) + )(compute_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUComputePass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void EndGPUComputePass(GPUComputePassHandle compute_pass) => + DllImport.EndGPUComputePass(compute_pass); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.EndGPUCopyPass(GPUCopyPassHandle copy_pass) => + ( + (delegate* unmanaged)( + _slots[181] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[181] = nativeContext.LoadFunction("SDL_EndGPUCopyPass", "SDL3") + ) + )(copy_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPUCopyPass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void EndGPUCopyPass(GPUCopyPassHandle copy_pass) => + DllImport.EndGPUCopyPass(copy_pass); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.EndGPURenderPass(GPURenderPassHandle render_pass) => + ( + (delegate* unmanaged)( + _slots[182] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[182] = nativeContext.LoadFunction("SDL_EndGPURenderPass", "SDL3") + ) + )(render_pass); + + [NativeFunction("SDL3", EntryPoint = "SDL_EndGPURenderPass")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void EndGPURenderPass(GPURenderPassHandle render_pass) => + DllImport.EndGPURenderPass(render_pass); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => + ( + (delegate* unmanaged< + int, + sbyte**, + AppInitFunc, + AppIterateFunc, + AppEventFunc, + AppQuitFunc, + int>)( + _slots[183] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[183] = nativeContext.LoadFunction("SDL_EnterAppMainCallbacks", "SDL3") + ) + )(argc, argv, appinit, appiter, appevent, appquit); + + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => DllImport.EnterAppMainCallbacks(argc, argv, appinit, appiter, appevent, appquit); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) { - fixed (Surface* __dsl_image = image) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).AddSurfaceAlternateImage(__dsl_surface, __dsl_image); + fixed (sbyte** __dsl_argv = argv) + { + return (int) + ((ISdl)this).EnterAppMainCallbacks( + argc, + __dsl_argv, + appinit, + appiter, + appevent, + appquit + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddSurfaceAlternateImage")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnterAppMainCallbacks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool AddSurfaceAlternateImage( - Ref surface, - Ref image - ) => DllImport.AddSurfaceAlternateImage(surface, image); + public static int EnterAppMainCallbacks( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_AppInit_func")] AppInitFunc appinit, + [NativeTypeName("SDL_AppIterate_func")] AppIterateFunc appiter, + [NativeTypeName("SDL_AppEvent_func")] AppEventFunc appevent, + [NativeTypeName("SDL_AppQuit_func")] AppQuitFunc appquit + ) => DllImport.EnterAppMainCallbacks(argc, argv, appinit, appiter, appevent, appquit); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + byte ISdl.EnumerateDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, void* userdata ) => ( - (delegate* unmanaged)( - _slots[8] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[184] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[8] = nativeContext.LoadFunction("SDL_AddTimer", "SDL3") + : _slots[184] = nativeContext.LoadFunction("SDL_EnumerateDirectory", "SDL3") ) - )(interval, callback, userdata); + )(path, callback, userdata); - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + public static byte EnumerateDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, void* userdata - ) => DllImport.AddTimer(interval, callback, userdata); + ) => DllImport.EnumerateDirectory(path, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + MaybeBool ISdl.EnumerateDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, Ref userdata ) { fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_path = path) { - return (uint)((ISdl)this).AddTimer(interval, callback, __dsl_userdata); + return (MaybeBool) + (byte)((ISdl)this).EnumerateDirectory(__dsl_path, callback, __dsl_userdata); } } - [return: NativeTypeName("SDL_TimerID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AddTimer( - [NativeTypeName("Uint32")] uint interval, - [NativeTypeName("SDL_TimerCallback")] TimerCallback callback, + public static MaybeBool EnumerateDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, Ref userdata - ) => DllImport.AddTimer(interval, callback, userdata); + ) => DllImport.EnumerateDirectory(path, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + byte ISdl.EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, void* userdata ) => ( - (delegate* unmanaged)( - _slots[9] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[185] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[9] = nativeContext.LoadFunction("SDL_AddTimerNS", "SDL3") + : _slots[185] = nativeContext.LoadFunction("SDL_EnumerateProperties", "SDL3") ) - )(interval, callback, userdata); + )(props, callback, userdata); - [return: NativeTypeName("SDL_TimerID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + public static byte EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, void* userdata - ) => DllImport.AddTimerNS(interval, callback, userdata); + ) => DllImport.EnumerateProperties(props, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, + MaybeBool ISdl.EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, Ref userdata ) { fixed (void* __dsl_userdata = userdata) { - return (uint)((ISdl)this).AddTimerNS(interval, callback, __dsl_userdata); + return (MaybeBool) + (byte)((ISdl)this).EnumerateProperties(props, callback, __dsl_userdata); } } - [return: NativeTypeName("SDL_TimerID")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddTimerNS")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AddTimerNS( - [NativeTypeName("Uint64")] ulong interval, - [NativeTypeName("SDL_NSTimerCallback")] NSTimerCallback callback, - Ref userdata - ) => DllImport.AddTimerNS(interval, callback, userdata); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.AddVulkanRenderSemaphores( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - (MaybeBool) - (byte) - ((ISdl)this).AddVulkanRenderSemaphoresRaw( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool AddVulkanRenderSemaphores( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - DllImport.AddVulkanRenderSemaphores( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); + public static MaybeBool EnumerateProperties( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, + Ref userdata + ) => DllImport.EnumerateProperties(props, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.AddVulkanRenderSemaphoresRaw( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore + byte ISdl.EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[10] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[186] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[10] = nativeContext.LoadFunction( - "SDL_AddVulkanRenderSemaphores", + : _slots[186] = nativeContext.LoadFunction( + "SDL_EnumerateStorageDirectory", "SDL3" ) ) - )(renderer, wait_stage_mask, wait_semaphore, signal_semaphore); + )(storage, path, callback, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AddVulkanRenderSemaphores")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte AddVulkanRenderSemaphoresRaw( - RendererHandle renderer, - [NativeTypeName("Uint32")] uint wait_stage_mask, - [NativeTypeName("Sint64")] long wait_semaphore, - [NativeTypeName("Sint64")] long signal_semaphore - ) => - DllImport.AddVulkanRenderSemaphoresRaw( - renderer, - wait_stage_mask, - wait_semaphore, - signal_semaphore - ); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc - ) => - ( - (delegate* unmanaged)( - _slots[11] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[11] = nativeContext.LoadFunction("SDL_AttachVirtualJoystick", "SDL3") - ) - )(desc); - - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] VirtualJoystickDesc* desc - ) => DllImport.AttachVirtualJoystick(desc); + public static byte EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + void* userdata + ) => DllImport.EnumerateStorageDirectory(storage, path, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc + MaybeBool ISdl.EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata ) { - fixed (VirtualJoystickDesc* __dsl_desc = desc) + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_path = path) { - return (uint)((ISdl)this).AttachVirtualJoystick(__dsl_desc); + return (MaybeBool) + (byte) + ((ISdl)this).EnumerateStorageDirectory( + storage, + __dsl_path, + callback, + __dsl_userdata + ); } } - [return: NativeTypeName("SDL_JoystickID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AttachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint AttachVirtualJoystick( - [NativeTypeName("const SDL_VirtualJoystickDesc *")] Ref desc - ) => DllImport.AttachVirtualJoystick(desc); + public static MaybeBool EnumerateStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, + Ref userdata + ) => DllImport.EnumerateStorageDirectory(storage, path, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.AudioDevicePaused([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - (MaybeBool)(byte)((ISdl)this).AudioDevicePausedRaw(dev); + MaybeBool ISdl.EventEnabled([NativeTypeName("Uint32")] uint type) => + (MaybeBool)(byte)((ISdl)this).EventEnabledRaw(type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool AudioDevicePaused( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => DllImport.AudioDevicePaused(dev); + public static MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => + DllImport.EventEnabled(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + byte ISdl.EventEnabledRaw([NativeTypeName("Uint32")] uint type) => ( (delegate* unmanaged)( - _slots[12] is not null and var loadedFnPtr + _slots[187] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[12] = nativeContext.LoadFunction("SDL_AudioDevicePaused", "SDL3") + : _slots[187] = nativeContext.LoadFunction("SDL_EventEnabled", "SDL3") ) - )(dev); + )(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_AudioDevicePaused")] + [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte AudioDevicePausedRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - DllImport.AudioDevicePausedRaw(dev); + public static byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => + DllImport.EventEnabledRaw(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BindAudioStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => (MaybeBool)(byte)((ISdl)this).BindAudioStreamRaw(devid, stream); + double ISdl.Exp(double x) => + ( + (delegate* unmanaged)( + _slots[188] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[188] = nativeContext.LoadFunction("SDL_exp", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_exp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BindAudioStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => DllImport.BindAudioStream(devid, stream); + public static double Exp(double x) => DllImport.Exp(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BindAudioStreamRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => + float ISdl.Expf(float x) => ( - (delegate* unmanaged)( - _slots[13] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[189] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[13] = nativeContext.LoadFunction("SDL_BindAudioStream", "SDL3") + : _slots[189] = nativeContext.LoadFunction("SDL_expf", "SDL3") ) - )(devid, stream); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_expf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BindAudioStreamRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle stream - ) => DllImport.BindAudioStreamRaw(devid, stream); + public static float Expf(float x) => DllImport.Expf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle* streams, - int num_streams + double ISdl.Fabs(double x) => + ( + (delegate* unmanaged)( + _slots[190] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[190] = nativeContext.LoadFunction("SDL_fabs", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_fabs")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Fabs(double x) => DllImport.Fabs(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.FillSurfaceRect( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("Uint32")] uint color ) => ( - (delegate* unmanaged)( - _slots[14] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[191] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[14] = nativeContext.LoadFunction("SDL_BindAudioStreams", "SDL3") + : _slots[191] = nativeContext.LoadFunction("SDL_FillSurfaceRect", "SDL3") ) - )(devid, streams, num_streams); + )(dst, rect, color); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioStreamHandle* streams, - int num_streams - ) => DllImport.BindAudioStreams(devid, streams, num_streams); + public static byte FillSurfaceRect( + Surface* dst, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + [NativeTypeName("Uint32")] uint color + ) => DllImport.FillSurfaceRect(dst, rect, color); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref streams, - int num_streams + MaybeBool ISdl.FillSurfaceRect( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("Uint32")] uint color ) { - fixed (AudioStreamHandle* __dsl_streams = streams) + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_dst = dst) { return (MaybeBool) - (byte)((ISdl)this).BindAudioStreams(devid, __dsl_streams, num_streams); + (byte)((ISdl)this).FillSurfaceRect(__dsl_dst, __dsl_rect, color); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BindAudioStreams")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BindAudioStreams( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref streams, - int num_streams - ) => DllImport.BindAudioStreams(devid, streams, num_streams); + public static MaybeBool FillSurfaceRect( + Ref dst, + [NativeTypeName("const SDL_Rect *")] Ref rect, + [NativeTypeName("Uint32")] uint color + ) => DllImport.FillSurfaceRect(dst, rect, color); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurface( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + byte ISdl.FillSurfaceRects( Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int count, + [NativeTypeName("Uint32")] uint color ) => ( - (delegate* unmanaged)( - _slots[15] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[192] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[15] = nativeContext.LoadFunction("SDL_BlitSurface", "SDL3") + : _slots[192] = nativeContext.LoadFunction("SDL_FillSurfaceRects", "SDL3") ) - )(src, srcrect, dst, dstrect); + )(dst, rects, count, color); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurface( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, + public static byte FillSurfaceRects( Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => DllImport.BlitSurface(src, srcrect, dst, dstrect); + [NativeTypeName("const SDL_Rect *")] Rect* rects, + int count, + [NativeTypeName("Uint32")] uint color + ) => DllImport.FillSurfaceRects(dst, rects, count, color); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurface( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, + MaybeBool ISdl.FillSurfaceRects( Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect + [NativeTypeName("const SDL_Rect *")] Ref rects, + int count, + [NativeTypeName("Uint32")] uint color ) { - fixed (Rect* __dsl_dstrect = dstrect) + fixed (Rect* __dsl_rects = rects) fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) { return (MaybeBool) - (byte)((ISdl)this).BlitSurface(__dsl_src, __dsl_srcrect, __dsl_dst, __dsl_dstrect); + (byte)((ISdl)this).FillSurfaceRects(__dsl_dst, __dsl_rects, count, color); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurface( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, + public static MaybeBool FillSurfaceRects( Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => DllImport.BlitSurface(src, srcrect, dst, dstrect); + [NativeTypeName("const SDL_Rect *")] Ref rects, + int count, + [NativeTypeName("Uint32")] uint color + ) => DllImport.FillSurfaceRects(dst, rects, count, color); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurface9Grid( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect + void ISdl.FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata ) => ( - (delegate* unmanaged< - Surface*, - Rect*, - int, - int, - int, - int, - float, - ScaleMode, - Surface*, - Rect*, - byte>)( - _slots[16] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[193] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[16] = nativeContext.LoadFunction("SDL_BlitSurface9Grid", "SDL3") + : _slots[193] = nativeContext.LoadFunction("SDL_FilterEvents", "SDL3") ) - )( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + )(filter, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurface9Grid( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => - DllImport.BlitSurface9Grid( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + public static void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => DllImport.FilterEvents(filter, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurface9Grid( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) + void ISdl.FilterEvents([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurface9Grid( - __dsl_src, - __dsl_srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - __dsl_dst, - __dsl_dstrect - ); + ((ISdl)this).FilterEvents(filter, __dsl_userdata); } } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void FilterEvents( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => DllImport.FilterEvents(filter, userdata); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.FlashWindow(WindowHandle window, FlashOperation operation) => + (MaybeBool)(byte)((ISdl)this).FlashWindowRaw(window, operation); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurface9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurface9Grid( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - int left_width, - int right_width, - int top_height, - int bottom_height, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => - DllImport.BlitSurface9Grid( - src, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - scaleMode, - dst, - dstrect - ); + public static MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => + DllImport.FlashWindow(window, operation); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.FlashWindowRaw(WindowHandle window, FlashOperation operation) => + ( + (delegate* unmanaged)( + _slots[194] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[194] = nativeContext.LoadFunction("SDL_FlashWindow", "SDL3") + ) + )(window, operation); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurfaceScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => + public static byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => + DllImport.FlashWindowRaw(window, operation); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.FlipSurface(Surface* surface, FlipMode flip) => ( - (delegate* unmanaged)( - _slots[17] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[195] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[17] = nativeContext.LoadFunction("SDL_BlitSurfaceScaled", "SDL3") + : _slots[195] = nativeContext.LoadFunction("SDL_FlipSurface", "SDL3") ) - )(src, srcrect, dst, dstrect, scaleMode); + )(surface, flip); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurfaceScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => DllImport.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); + public static byte FlipSurface(Surface* surface, FlipMode flip) => + DllImport.FlipSurface(surface, flip); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurfaceScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) + MaybeBool ISdl.FlipSurface(Ref surface, FlipMode flip) { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurfaceScaled( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect, - scaleMode - ); + return (MaybeBool)(byte)((ISdl)this).FlipSurface(__dsl_surface, flip); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurfaceScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) => DllImport.BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode); + public static MaybeBool FlipSurface(Ref surface, FlipMode flip) => + DllImport.FlipSurface(surface, flip); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurfaceTiled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => + double ISdl.Floor(double x) => ( - (delegate* unmanaged)( - _slots[18] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[196] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[18] = nativeContext.LoadFunction("SDL_BlitSurfaceTiled", "SDL3") + : _slots[196] = nativeContext.LoadFunction("SDL_floor", "SDL3") ) - )(src, srcrect, dst, dstrect); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_floor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurfaceTiled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => DllImport.BlitSurfaceTiled(src, srcrect, dst, dstrect); + public static double Floor(double x) => DllImport.Floor(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurfaceTiled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurfaceTiled( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect - ); - } - } + float ISdl.Floorf(float x) => + ( + (delegate* unmanaged)( + _slots[197] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[197] = nativeContext.LoadFunction("SDL_floorf", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_floorf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Floorf(float x) => DllImport.Floorf(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.FlushAudioStream(AudioStreamHandle stream) => + (MaybeBool)(byte)((ISdl)this).FlushAudioStreamRaw(stream); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurfaceTiled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => DllImport.BlitSurfaceTiled(src, srcrect, dst, dstrect); + public static MaybeBool FlushAudioStream(AudioStreamHandle stream) => + DllImport.FlushAudioStream(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurfaceTiledWithScale( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => + byte ISdl.FlushAudioStreamRaw(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[19] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[198] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[19] = nativeContext.LoadFunction( - "SDL_BlitSurfaceTiledWithScale", - "SDL3" - ) + : _slots[198] = nativeContext.LoadFunction("SDL_FlushAudioStream", "SDL3") ) - )(src, srcrect, scale, scaleMode, dst, dstrect); + )(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurfaceTiledWithScale( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - float scale, - ScaleMode scaleMode, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => DllImport.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); + public static byte FlushAudioStreamRaw(AudioStreamHandle stream) => + DllImport.FlushAudioStreamRaw(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurfaceTiledWithScale( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurfaceTiledWithScale( - __dsl_src, - __dsl_srcrect, - scale, - scaleMode, - __dsl_dst, - __dsl_dstrect - ); - } - } + void ISdl.FlushEvent([NativeTypeName("Uint32")] uint type) => + ( + (delegate* unmanaged)( + _slots[199] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[199] = nativeContext.LoadFunction("SDL_FlushEvent", "SDL3") + ) + )(type); + + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void FlushEvent([NativeTypeName("Uint32")] uint type) => + DllImport.FlushEvent(type); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.FlushEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => + ( + (delegate* unmanaged)( + _slots[200] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[200] = nativeContext.LoadFunction("SDL_FlushEvents", "SDL3") + ) + )(minType, maxType); + + [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void FlushEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => DllImport.FlushEvents(minType, maxType); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.FlushIO(IOStreamHandle context) => + (MaybeBool)(byte)((ISdl)this).FlushIORaw(context); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceTiledWithScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurfaceTiledWithScale( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - float scale, - ScaleMode scaleMode, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => DllImport.BlitSurfaceTiledWithScale(src, srcrect, scale, scaleMode, dst, dstrect); + public static MaybeBool FlushIO(IOStreamHandle context) => DllImport.FlushIO(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurfaceUnchecked( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => + byte ISdl.FlushIORaw(IOStreamHandle context) => ( - (delegate* unmanaged)( - _slots[20] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[201] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[20] = nativeContext.LoadFunction("SDL_BlitSurfaceUnchecked", "SDL3") + : _slots[201] = nativeContext.LoadFunction("SDL_FlushIO", "SDL3") ) - )(src, srcrect, dst, dstrect); + )(context); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurfaceUnchecked( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect - ) => DllImport.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + public static byte FlushIORaw(IOStreamHandle context) => DllImport.FlushIORaw(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurfaceUnchecked( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) - { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) - { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurfaceUnchecked( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect - ); - } - } + MaybeBool ISdl.FlushRenderer(RendererHandle renderer) => + (MaybeBool)(byte)((ISdl)this).FlushRendererRaw(renderer); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUnchecked")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurfaceUnchecked( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect - ) => DllImport.BlitSurfaceUnchecked(src, srcrect, dst, dstrect); + public static MaybeBool FlushRenderer(RendererHandle renderer) => + DllImport.FlushRenderer(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.BlitSurfaceUncheckedScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => + byte ISdl.FlushRendererRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[21] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[202] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[21] = nativeContext.LoadFunction( - "SDL_BlitSurfaceUncheckedScaled", - "SDL3" - ) + : _slots[202] = nativeContext.LoadFunction("SDL_FlushRenderer", "SDL3") ) - )(src, srcrect, dst, dstrect, scaleMode); + )(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte BlitSurfaceUncheckedScaled( - Surface* src, - [NativeTypeName("const SDL_Rect *")] Rect* srcrect, - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* dstrect, - ScaleMode scaleMode - ) => DllImport.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); + public static byte FlushRendererRaw(RendererHandle renderer) => + DllImport.FlushRendererRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.BlitSurfaceUncheckedScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) + double ISdl.Fmod(double x, double y) => + ( + (delegate* unmanaged)( + _slots[203] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[203] = nativeContext.LoadFunction("SDL_fmod", "SDL3") + ) + )(x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_fmod")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Fmod(double x, double y) => DllImport.Fmod(x, y); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Fmodf(float x, float y) => + ( + (delegate* unmanaged)( + _slots[204] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[204] = nativeContext.LoadFunction("SDL_fmodf", "SDL3") + ) + )(x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_fmodf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Fmodf(float x, float y) => DllImport.Fmodf(x, y); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.Free(void* mem) => + ( + (delegate* unmanaged)( + _slots[205] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[205] = nativeContext.LoadFunction("SDL_free", "SDL3") + ) + )(mem); + + [NativeFunction("SDL3", EntryPoint = "SDL_free")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void Free(void* mem) => DllImport.Free(mem); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.Free(Ref mem) { - fixed (Rect* __dsl_dstrect = dstrect) - fixed (Surface* __dsl_dst = dst) - fixed (Rect* __dsl_srcrect = srcrect) - fixed (Surface* __dsl_src = src) + fixed (void* __dsl_mem = mem) { - return (MaybeBool) - (byte) - ((ISdl)this).BlitSurfaceUncheckedScaled( - __dsl_src, - __dsl_srcrect, - __dsl_dst, - __dsl_dstrect, - scaleMode - ); + ((ISdl)this).Free(__dsl_mem); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_BlitSurfaceUncheckedScaled")] + [NativeFunction("SDL3", EntryPoint = "SDL_free")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool BlitSurfaceUncheckedScaled( - Ref src, - [NativeTypeName("const SDL_Rect *")] Ref srcrect, - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref dstrect, - ScaleMode scaleMode - ) => DllImport.BlitSurfaceUncheckedScaled(src, srcrect, dst, dstrect, scaleMode); + public static void Free(Ref mem) => DllImport.Free(mem); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.BroadcastCondition(ConditionHandle cond) => - ( - (delegate* unmanaged)( - _slots[22] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[22] = nativeContext.LoadFunction("SDL_BroadcastCondition", "SDL3") - ) - )(cond); + MaybeBool ISdl.GamepadConnected(GamepadHandle gamepad) => + (MaybeBool)(byte)((ISdl)this).GamepadConnectedRaw(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_BroadcastCondition")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void BroadcastCondition(ConditionHandle cond) => - DllImport.BroadcastCondition(cond); + public static MaybeBool GamepadConnected(GamepadHandle gamepad) => + DllImport.GamepadConnected(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CaptureMouse([NativeTypeName("bool")] byte enabled) => + byte ISdl.GamepadConnectedRaw(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[23] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[206] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[23] = nativeContext.LoadFunction("SDL_CaptureMouse", "SDL3") + : _slots[206] = nativeContext.LoadFunction("SDL_GamepadConnected", "SDL3") ) - )(enabled); + )(gamepad); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CaptureMouse([NativeTypeName("bool")] byte enabled) => - DllImport.CaptureMouse(enabled); + public static byte GamepadConnectedRaw(GamepadHandle gamepad) => + DllImport.GamepadConnectedRaw(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => - (MaybeBool)(byte)((ISdl)this).CaptureMouse((byte)enabled); + MaybeBool ISdl.GamepadEventsEnabled() => + (MaybeBool)(byte)((ISdl)this).GamepadEventsEnabledRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CaptureMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CaptureMouse([NativeTypeName("bool")] MaybeBool enabled) => - DllImport.CaptureMouse(enabled); + public static MaybeBool GamepadEventsEnabled() => DllImport.GamepadEventsEnabled(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CleanupTLS() => + byte ISdl.GamepadEventsEnabledRaw() => ( - (delegate* unmanaged)( - _slots[24] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[207] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[24] = nativeContext.LoadFunction("SDL_CleanupTLS", "SDL3") + : _slots[207] = nativeContext.LoadFunction("SDL_GamepadEventsEnabled", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CleanupTLS")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CleanupTLS() => DllImport.CleanupTLS(); + public static byte GamepadEventsEnabledRaw() => DllImport.GamepadEventsEnabledRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearAudioStream(AudioStreamHandle stream) => - (MaybeBool)(byte)((ISdl)this).ClearAudioStreamRaw(stream); + MaybeBool ISdl.GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => + (MaybeBool)(byte)((ISdl)this).GamepadHasAxisRaw(gamepad, axis); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearAudioStream(AudioStreamHandle stream) => - DllImport.ClearAudioStream(stream); + public static MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => + DllImport.GamepadHasAxis(gamepad, axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearAudioStreamRaw(AudioStreamHandle stream) => + byte ISdl.GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => ( - (delegate* unmanaged)( - _slots[25] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[208] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[25] = nativeContext.LoadFunction("SDL_ClearAudioStream", "SDL3") + : _slots[208] = nativeContext.LoadFunction("SDL_GamepadHasAxis", "SDL3") ) - )(stream); + )(gamepad, axis); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearAudioStreamRaw(AudioStreamHandle stream) => - DllImport.ClearAudioStreamRaw(stream); + public static byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => + DllImport.GamepadHasAxisRaw(gamepad, axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearClipboardData() => - (MaybeBool)(byte)((ISdl)this).ClearClipboardDataRaw(); + MaybeBool ISdl.GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => + (MaybeBool)(byte)((ISdl)this).GamepadHasButtonRaw(gamepad, button); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearClipboardData() => DllImport.ClearClipboardData(); + public static MaybeBool GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => + DllImport.GamepadHasButton(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearClipboardDataRaw() => + byte ISdl.GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => ( - (delegate* unmanaged)( - _slots[26] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[209] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[26] = nativeContext.LoadFunction("SDL_ClearClipboardData", "SDL3") + : _slots[209] = nativeContext.LoadFunction("SDL_GamepadHasButton", "SDL3") ) - )(); + )(gamepad, button); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearClipboardDataRaw() => DllImport.ClearClipboardDataRaw(); + public static byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => + DllImport.GamepadHasButtonRaw(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearComposition(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).ClearCompositionRaw(window); + MaybeBool ISdl.GamepadHasSensor(GamepadHandle gamepad, SensorType type) => + (MaybeBool)(byte)((ISdl)this).GamepadHasSensorRaw(gamepad, type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearComposition(WindowHandle window) => - DllImport.ClearComposition(window); + public static MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => + DllImport.GamepadHasSensor(gamepad, type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearCompositionRaw(WindowHandle window) => + byte ISdl.GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => ( - (delegate* unmanaged)( - _slots[27] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[210] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[27] = nativeContext.LoadFunction("SDL_ClearComposition", "SDL3") + : _slots[210] = nativeContext.LoadFunction("SDL_GamepadHasSensor", "SDL3") ) - )(window); + )(gamepad, type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearComposition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearCompositionRaw(WindowHandle window) => - DllImport.ClearCompositionRaw(window); + public static byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => + DllImport.GamepadHasSensorRaw(gamepad, type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearError() => (MaybeBool)(byte)((ISdl)this).ClearErrorRaw(); + MaybeBool ISdl.GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => + (MaybeBool)(byte)((ISdl)this).GamepadSensorEnabledRaw(gamepad, type); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => + DllImport.GamepadSensorEnabled(gamepad, type); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => + ( + (delegate* unmanaged)( + _slots[211] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[211] = nativeContext.LoadFunction("SDL_GamepadSensorEnabled", "SDL3") + ) + )(gamepad, type); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearError() => DllImport.ClearError(); + public static byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => + DllImport.GamepadSensorEnabledRaw(gamepad, type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearErrorRaw() => + void ISdl.GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ) => ( - (delegate* unmanaged)( - _slots[28] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[212] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[28] = nativeContext.LoadFunction("SDL_ClearError", "SDL3") + : _slots[212] = nativeContext.LoadFunction( + "SDL_GenerateMipmapsForGPUTexture", + "SDL3" + ) ) - )(); + )(command_buffer, texture); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearError")] + [NativeFunction("SDL3", EntryPoint = "SDL_GenerateMipmapsForGPUTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearErrorRaw() => DllImport.ClearErrorRaw(); + public static void GenerateMipmapsForGPUTexture( + GPUCommandBufferHandle command_buffer, + GPUTextureHandle texture + ) => DllImport.GenerateMipmapsForGPUTexture(command_buffer, texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => + sbyte* ISdl.GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[29] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[213] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[29] = nativeContext.LoadFunction("SDL_ClearProperty", "SDL3") + : _slots[213] = nativeContext.LoadFunction("SDL_GetAppMetadataProperty", "SDL3") ) - )(props, name); + )(name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.ClearProperty(props, name); + public static sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => + DllImport.GetAppMetadataProperty(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) + Ptr ISdl.GetAppMetadataProperty([NativeTypeName("const char *")] Ref name) { fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).ClearProperty(props, __dsl_name); + return (sbyte*)((ISdl)this).GetAppMetadataProperty(__dsl_name); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, + public static Ptr GetAppMetadataProperty( [NativeTypeName("const char *")] Ref name - ) => DllImport.ClearProperty(props, name); + ) => DllImport.GetAppMetadataProperty(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ClearSurface(Surface* surface, float r, float g, float b, float a) => + AssertionHandler ISdl.GetAssertionHandler(void** puserdata) => ( - (delegate* unmanaged)( - _slots[30] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[214] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[30] = nativeContext.LoadFunction("SDL_ClearSurface", "SDL3") + : _slots[214] = nativeContext.LoadFunction("SDL_GetAssertionHandler", "SDL3") ) - )(surface, r, g, b, a); + )(puserdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ClearSurface(Surface* surface, float r, float g, float b, float a) => - DllImport.ClearSurface(surface, r, g, b, a); + public static AssertionHandler GetAssertionHandler(void** puserdata) => + DllImport.GetAssertionHandler(puserdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ClearSurface(Ref surface, float r, float g, float b, float a) + AssertionHandler ISdl.GetAssertionHandler(Ref2D puserdata) { - fixed (Surface* __dsl_surface = surface) + fixed (void** __dsl_puserdata = puserdata) { - return (MaybeBool)(byte)((ISdl)this).ClearSurface(__dsl_surface, r, g, b, a); + return (AssertionHandler)((ISdl)this).GetAssertionHandler(__dsl_puserdata); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_AssertionHandler")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ClearSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ClearSurface( - Ref surface, - float r, - float g, - float b, - float a - ) => DllImport.ClearSurface(surface, r, g, b, a); + public static AssertionHandler GetAssertionHandler(Ref2D puserdata) => + DllImport.GetAssertionHandler(puserdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - ( - (delegate* unmanaged)( - _slots[31] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[31] = nativeContext.LoadFunction("SDL_CloseAudioDevice", "SDL3") - ) - )(devid); + Ptr ISdl.GetAssertionReport() => (AssertData*)((ISdl)this).GetAssertionReportRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseAudioDevice")] + [return: NativeTypeName("const SDL_AssertData *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - DllImport.CloseAudioDevice(devid); + public static Ptr GetAssertionReport() => DllImport.GetAssertionReport(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseCamera(CameraHandle camera) => + AssertData* ISdl.GetAssertionReportRaw() => ( - (delegate* unmanaged)( - _slots[32] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[215] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[32] = nativeContext.LoadFunction("SDL_CloseCamera", "SDL3") + : _slots[215] = nativeContext.LoadFunction("SDL_GetAssertionReport", "SDL3") ) - )(camera); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseCamera")] + [return: NativeTypeName("const SDL_AssertData *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseCamera(CameraHandle camera) => DllImport.CloseCamera(camera); + public static AssertData* GetAssertionReportRaw() => DllImport.GetAssertionReportRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseGamepad(GamepadHandle gamepad) => + int ISdl.GetAtomicInt(AtomicInt* a) => ( - (delegate* unmanaged)( - _slots[33] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[216] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[33] = nativeContext.LoadFunction("SDL_CloseGamepad", "SDL3") + : _slots[216] = nativeContext.LoadFunction("SDL_GetAtomicInt", "SDL3") ) - )(gamepad); + )(a); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseGamepad(GamepadHandle gamepad) => DllImport.CloseGamepad(gamepad); + public static int GetAtomicInt(AtomicInt* a) => DllImport.GetAtomicInt(a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseHaptic(HapticHandle haptic) => + int ISdl.GetAtomicInt(Ref a) + { + fixed (AtomicInt* __dsl_a = a) + { + return (int)((ISdl)this).GetAtomicInt(__dsl_a); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int GetAtomicInt(Ref a) => DllImport.GetAtomicInt(a); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void* ISdl.GetAtomicPointer(void** a) => ( - (delegate* unmanaged)( - _slots[34] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[217] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[34] = nativeContext.LoadFunction("SDL_CloseHaptic", "SDL3") + : _slots[217] = nativeContext.LoadFunction("SDL_GetAtomicPointer", "SDL3") ) - )(haptic); + )(a); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseHaptic(HapticHandle haptic) => DllImport.CloseHaptic(haptic); + public static void* GetAtomicPointer(void** a) => DllImport.GetAtomicPointer(a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CloseIO(IOStreamHandle context) => - (MaybeBool)(byte)((ISdl)this).CloseIORaw(context); + Ptr ISdl.GetAtomicPointer(Ref2D a) + { + fixed (void** __dsl_a = a) + { + return (void*)((ISdl)this).GetAtomicPointer(__dsl_a); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CloseIO(IOStreamHandle context) => DllImport.CloseIO(context); + public static Ptr GetAtomicPointer(Ref2D a) => DllImport.GetAtomicPointer(a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CloseIORaw(IOStreamHandle context) => + uint ISdl.GetAtomicU32(AtomicU32* a) => ( - (delegate* unmanaged)( - _slots[35] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[218] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[35] = nativeContext.LoadFunction("SDL_CloseIO", "SDL3") + : _slots[218] = nativeContext.LoadFunction("SDL_GetAtomicU32", "SDL3") ) - )(context); + )(a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseIO")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CloseIORaw(IOStreamHandle context) => DllImport.CloseIORaw(context); + public static uint GetAtomicU32(AtomicU32* a) => DllImport.GetAtomicU32(a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseJoystick(JoystickHandle joystick) => - ( - (delegate* unmanaged)( - _slots[36] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[36] = nativeContext.LoadFunction("SDL_CloseJoystick", "SDL3") - ) - )(joystick); + uint ISdl.GetAtomicU32(Ref a) + { + fixed (AtomicU32* __dsl_a = a) + { + return (uint)((ISdl)this).GetAtomicU32(__dsl_a); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_CloseJoystick")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseJoystick(JoystickHandle joystick) => DllImport.CloseJoystick(joystick); + public static uint GetAtomicU32(Ref a) => DllImport.GetAtomicU32(a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.CloseSensor(SensorHandle sensor) => + int* ISdl.GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + int* count + ) => ( - (delegate* unmanaged)( - _slots[37] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[219] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[37] = nativeContext.LoadFunction("SDL_CloseSensor", "SDL3") + : _slots[219] = nativeContext.LoadFunction( + "SDL_GetAudioDeviceChannelMap", + "SDL3" + ) ) - )(sensor); + )(devid, count); - [NativeFunction("SDL3", EntryPoint = "SDL_CloseSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void CloseSensor(SensorHandle sensor) => DllImport.CloseSensor(sensor); + public static int* GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + int* count + ) => DllImport.GetAudioDeviceChannelMap(devid, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CloseStorage(StorageHandle storage) => - (MaybeBool)(byte)((ISdl)this).CloseStorageRaw(storage); + Ptr ISdl.GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (int*)((ISdl)this).GetAudioDeviceChannelMap(devid, __dsl_count); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CloseStorage(StorageHandle storage) => - DllImport.CloseStorage(storage); + public static Ptr GetAudioDeviceChannelMap( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref count + ) => DllImport.GetAudioDeviceChannelMap(devid, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CloseStorageRaw(StorageHandle storage) => + byte ISdl.GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioSpec* spec, + int* sample_frames + ) => ( - (delegate* unmanaged)( - _slots[38] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[220] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[38] = nativeContext.LoadFunction("SDL_CloseStorage", "SDL3") + : _slots[220] = nativeContext.LoadFunction("SDL_GetAudioDeviceFormat", "SDL3") ) - )(storage); + )(devid, spec, sample_frames); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CloseStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CloseStorageRaw(StorageHandle storage) => DllImport.CloseStorageRaw(storage); + public static byte GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + AudioSpec* spec, + int* sample_frames + ) => DllImport.GetAudioDeviceFormat(devid, spec, sample_frames); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => + MaybeBool ISdl.GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref spec, + Ref sample_frames + ) + { + fixed (int* __dsl_sample_frames = sample_frames) + fixed (AudioSpec* __dsl_spec = spec) + { + return (MaybeBool) + (byte)((ISdl)this).GetAudioDeviceFormat(devid, __dsl_spec, __dsl_sample_frames); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetAudioDeviceFormat( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + Ref spec, + Ref sample_frames + ) => DllImport.GetAudioDeviceFormat(devid, spec, sample_frames); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => ( - (delegate* unmanaged)( - _slots[39] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[221] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[39] = nativeContext.LoadFunction("SDL_CompareAndSwapAtomicInt", "SDL3") + : _slots[221] = nativeContext.LoadFunction("SDL_GetAudioDeviceGain", "SDL3") ) - )(a, oldval, newval); + )(devid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CompareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) => - DllImport.CompareAndSwapAtomicInt(a, oldval, newval); + public static float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + DllImport.GetAudioDeviceGain(devid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CompareAndSwapAtomicInt(Ref a, int oldval, int newval) - { - fixed (AtomicInt* __dsl_a = a) - { - return (MaybeBool) - (byte)((ISdl)this).CompareAndSwapAtomicInt(__dsl_a, oldval, newval); - } - } + Ptr ISdl.GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + (sbyte*)((ISdl)this).GetAudioDeviceNameRaw(devid); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CompareAndSwapAtomicInt( - Ref a, - int oldval, - int newval - ) => DllImport.CompareAndSwapAtomicInt(a, oldval, newval); + public static Ptr GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + DllImport.GetAudioDeviceName(devid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => + sbyte* ISdl.GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => ( - (delegate* unmanaged)( - _slots[40] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[222] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[40] = nativeContext.LoadFunction( - "SDL_CompareAndSwapAtomicPointer", - "SDL3" - ) + : _slots[222] = nativeContext.LoadFunction("SDL_GetAudioDeviceName", "SDL3") ) - )(a, oldval, newval); + )(devid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CompareAndSwapAtomicPointer(void** a, void* oldval, void* newval) => - DllImport.CompareAndSwapAtomicPointer(a, oldval, newval); + public static sbyte* GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + DllImport.GetAudioDeviceNameRaw(devid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) - { - fixed (void* __dsl_newval = newval) - fixed (void* __dsl_oldval = oldval) - fixed (void** __dsl_a = a) - { - return (MaybeBool) - (byte)((ISdl)this).CompareAndSwapAtomicPointer(__dsl_a, __dsl_oldval, __dsl_newval); - } - } + Ptr ISdl.GetAudioDriver(int index) => (sbyte*)((ISdl)this).GetAudioDriverRaw(index); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CompareAndSwapAtomicPointer(Ref2D a, Ref oldval, Ref newval) => - DllImport.CompareAndSwapAtomicPointer(a, oldval, newval); + public static Ptr GetAudioDriver(int index) => DllImport.GetAudioDriver(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CompareAndSwapAtomicU32( - AtomicU32* a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => + sbyte* ISdl.GetAudioDriverRaw(int index) => ( - (delegate* unmanaged)( - _slots[41] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[223] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[41] = nativeContext.LoadFunction("SDL_CompareAndSwapAtomicU32", "SDL3") + : _slots[223] = nativeContext.LoadFunction("SDL_GetAudioDriver", "SDL3") ) - )(a, oldval, newval); + )(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CompareAndSwapAtomicU32( - AtomicU32* a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => DllImport.CompareAndSwapAtomicU32(a, oldval, newval); + public static sbyte* GetAudioDriverRaw(int index) => DllImport.GetAudioDriverRaw(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CompareAndSwapAtomicU32( - Ref a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) - { - fixed (AtomicU32* __dsl_a = a) - { - return (MaybeBool) - (byte)((ISdl)this).CompareAndSwapAtomicU32(__dsl_a, oldval, newval); - } - } + Ptr ISdl.GetAudioFormatName(AudioFormat format) => + (sbyte*)((ISdl)this).GetAudioFormatNameRaw(format); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CompareAndSwapAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CompareAndSwapAtomicU32( - Ref a, - [NativeTypeName("Uint32")] uint oldval, - [NativeTypeName("Uint32")] uint newval - ) => DllImport.CompareAndSwapAtomicU32(a, oldval, newval); + public static Ptr GetAudioFormatName(AudioFormat format) => + DllImport.GetAudioFormatName(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.ComposeCustomBlendMode( - BlendFactor srcColorFactor, - BlendFactor dstColorFactor, - BlendOperation colorOperation, - BlendFactor srcAlphaFactor, - BlendFactor dstAlphaFactor, - BlendOperation alphaOperation - ) => + sbyte* ISdl.GetAudioFormatNameRaw(AudioFormat format) => ( - (delegate* unmanaged< - BlendFactor, - BlendFactor, - BlendOperation, - BlendFactor, - BlendFactor, - BlendOperation, - uint>)( - _slots[42] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[224] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[42] = nativeContext.LoadFunction("SDL_ComposeCustomBlendMode", "SDL3") + : _slots[224] = nativeContext.LoadFunction("SDL_GetAudioFormatName", "SDL3") ) - )( - srcColorFactor, - dstColorFactor, - colorOperation, - srcAlphaFactor, - dstAlphaFactor, - alphaOperation - ); + )(format); - [return: NativeTypeName("SDL_BlendMode")] - [NativeFunction("SDL3", EntryPoint = "SDL_ComposeCustomBlendMode")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint ComposeCustomBlendMode( - BlendFactor srcColorFactor, - BlendFactor dstColorFactor, - BlendOperation colorOperation, - BlendFactor srcAlphaFactor, - BlendFactor dstAlphaFactor, - BlendOperation alphaOperation - ) => - DllImport.ComposeCustomBlendMode( - srcColorFactor, - dstColorFactor, - colorOperation, - srcAlphaFactor, - dstAlphaFactor, - alphaOperation - ); + public static sbyte* GetAudioFormatNameRaw(AudioFormat format) => + DllImport.GetAudioFormatNameRaw(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const Uint8 *")] byte* src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, - [NativeTypeName("Uint8 **")] byte** dst_data, - int* dst_len - ) => + uint* ISdl.GetAudioPlaybackDevices(int* count) => ( - (delegate* unmanaged)( - _slots[43] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[225] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[43] = nativeContext.LoadFunction("SDL_ConvertAudioSamples", "SDL3") + : _slots[225] = nativeContext.LoadFunction( + "SDL_GetAudioPlaybackDevices", + "SDL3" + ) ) - )(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + )(count); + + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* GetAudioPlaybackDevices(int* count) => + DllImport.GetAudioPlaybackDevices(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetAudioPlaybackDevices(Ref count) + { + fixed (int* __dsl_count = count) + { + return (uint*)((ISdl)this).GetAudioPlaybackDevices(__dsl_count); + } + } + + [return: NativeTypeName("SDL_AudioDeviceID *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetAudioPlaybackDevices(Ref count) => + DllImport.GetAudioPlaybackDevices(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint* ISdl.GetAudioRecordingDevices(int* count) => + ( + (delegate* unmanaged)( + _slots[226] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[226] = nativeContext.LoadFunction( + "SDL_GetAudioRecordingDevices", + "SDL3" + ) + ) + )(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [return: NativeTypeName("SDL_AudioDeviceID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const Uint8 *")] byte* src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec, - [NativeTypeName("Uint8 **")] byte** dst_data, - int* dst_len - ) => DllImport.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + public static uint* GetAudioRecordingDevices(int* count) => + DllImport.GetAudioRecordingDevices(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const Uint8 *")] Ref src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, - [NativeTypeName("Uint8 **")] Ref2D dst_data, - Ref dst_len - ) + Ptr ISdl.GetAudioRecordingDevices(Ref count) { - fixed (int* __dsl_dst_len = dst_len) - fixed (byte** __dsl_dst_data = dst_data) - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (byte* __dsl_src_data = src_data) - fixed (AudioSpec* __dsl_src_spec = src_spec) + fixed (int* __dsl_count = count) { - return (MaybeBool) - (byte) - ((ISdl)this).ConvertAudioSamples( - __dsl_src_spec, - __dsl_src_data, - src_len, - __dsl_dst_spec, - __dsl_dst_data, - __dsl_dst_len - ); + return (uint*)((ISdl)this).GetAudioRecordingDevices(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_AudioDeviceID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertAudioSamples")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ConvertAudioSamples( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const Uint8 *")] Ref src_data, - int src_len, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec, - [NativeTypeName("Uint8 **")] Ref2D dst_data, - Ref dst_len - ) => DllImport.ConvertAudioSamples(src_spec, src_data, src_len, dst_spec, dst_data, dst_len); + public static Ptr GetAudioRecordingDevices(Ref count) => + DllImport.GetAudioRecordingDevices(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => + int ISdl.GetAudioStreamAvailable(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[44] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[227] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[44] = nativeContext.LoadFunction( - "SDL_ConvertEventToRenderCoordinates", + : _slots[227] = nativeContext.LoadFunction( + "SDL_GetAudioStreamAvailable", "SDL3" ) ) - )(renderer, @event); + )(stream); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ConvertEventToRenderCoordinates(RendererHandle renderer, Event* @event) => - DllImport.ConvertEventToRenderCoordinates(renderer, @event); + public static int GetAudioStreamAvailable(AudioStreamHandle stream) => + DllImport.GetAudioStreamAvailable(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ConvertEventToRenderCoordinates(RendererHandle renderer, Ref @event) + int ISdl.GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => + ( + (delegate* unmanaged)( + _slots[228] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[228] = nativeContext.LoadFunction("SDL_GetAudioStreamData", "SDL3") + ) + )(stream, buf, len); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => + DllImport.GetAudioStreamData(stream, buf, len); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) { - fixed (Event* __dsl_event = @event) + fixed (void* __dsl_buf = buf) { - return (MaybeBool) - (byte)((ISdl)this).ConvertEventToRenderCoordinates(renderer, __dsl_event); + return (int)((ISdl)this).GetAudioStreamData(stream, __dsl_buf, len); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertEventToRenderCoordinates")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ConvertEventToRenderCoordinates( - RendererHandle renderer, - Ref @event - ) => DllImport.ConvertEventToRenderCoordinates(renderer, @event); + public static int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) => + DllImport.GetAudioStreamData(stream, buf, len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch + uint ISdl.GetAudioStreamDevice(AudioStreamHandle stream) => + ( + (delegate* unmanaged)( + _slots[229] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[229] = nativeContext.LoadFunction("SDL_GetAudioStreamDevice", "SDL3") + ) + )(stream); + + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint GetAudioStreamDevice(AudioStreamHandle stream) => + DllImport.GetAudioStreamDevice(stream); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetAudioStreamFormat( + AudioStreamHandle stream, + AudioSpec* src_spec, + AudioSpec* dst_spec ) => ( - (delegate* unmanaged)( - _slots[45] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[230] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[45] = nativeContext.LoadFunction("SDL_ConvertPixels", "SDL3") + : _slots[230] = nativeContext.LoadFunction("SDL_GetAudioStreamFormat", "SDL3") ) - )(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch); + )(stream, src_spec, dst_spec); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch - ) => - DllImport.ConvertPixels( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch - ); + public static byte GetAudioStreamFormat( + AudioStreamHandle stream, + AudioSpec* src_spec, + AudioSpec* dst_spec + ) => DllImport.GetAudioStreamFormat(stream, src_spec, dst_spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch + MaybeBool ISdl.GetAudioStreamFormat( + AudioStreamHandle stream, + Ref src_spec, + Ref dst_spec ) { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) { return (MaybeBool) - (byte) - ((ISdl)this).ConvertPixels( - width, - height, - src_format, - __dsl_src, - src_pitch, - dst_format, - __dsl_dst, - dst_pitch - ); + (byte)((ISdl)this).GetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ConvertPixels( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch - ) => - DllImport.ConvertPixels( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch - ); + public static MaybeBool GetAudioStreamFormat( + AudioStreamHandle stream, + Ref src_spec, + Ref dst_spec + ) => DllImport.GetAudioStreamFormat(stream, src_spec, dst_spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - void* dst, - int dst_pitch - ) => + float ISdl.GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => ( - (delegate* unmanaged< - int, - int, - PixelFormat, - Colorspace, - uint, - void*, - int, - PixelFormat, - Colorspace, - uint, - void*, - int, - byte>)( - _slots[46] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[231] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[46] = nativeContext.LoadFunction( - "SDL_ConvertPixelsAndColorspace", + : _slots[231] = nativeContext.LoadFunction( + "SDL_GetAudioStreamFrequencyRatio", "SDL3" ) ) - )( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + )(stream); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - void* dst, - int dst_pitch - ) => - DllImport.ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + public static float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => + DllImport.GetAudioStreamFrequencyRatio(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - Ref dst, - int dst_pitch - ) + float ISdl.GetAudioStreamGain(AudioStreamHandle stream) => + ( + (delegate* unmanaged)( + _slots[232] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[232] = nativeContext.LoadFunction("SDL_GetAudioStreamGain", "SDL3") + ) + )(stream); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float GetAudioStreamGain(AudioStreamHandle stream) => + DllImport.GetAudioStreamGain(stream); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int* ISdl.GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => + ( + (delegate* unmanaged)( + _slots[233] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[233] = nativeContext.LoadFunction( + "SDL_GetAudioStreamInputChannelMap", + "SDL3" + ) + ) + )(stream, count); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => + DllImport.GetAudioStreamInputChannelMap(stream, count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetAudioStreamInputChannelMap(AudioStreamHandle stream, Ref count) { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) + fixed (int* __dsl_count = count) { - return (MaybeBool) - (byte) - ((ISdl)this).ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - __dsl_src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - __dsl_dst, - dst_pitch - ); + return (int*)((ISdl)this).GetAudioStreamInputChannelMap(stream, __dsl_count); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertPixelsAndColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ConvertPixelsAndColorspace( - int width, - int height, - PixelFormat src_format, - Colorspace src_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint src_properties, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Colorspace dst_colorspace, - [NativeTypeName("SDL_PropertiesID")] uint dst_properties, - Ref dst, - int dst_pitch - ) => - DllImport.ConvertPixelsAndColorspace( - width, - height, - src_format, - src_colorspace, - src_properties, - src, - src_pitch, - dst_format, - dst_colorspace, - dst_properties, - dst, - dst_pitch - ); + public static Ptr GetAudioStreamInputChannelMap( + AudioStreamHandle stream, + Ref count + ) => DllImport.GetAudioStreamInputChannelMap(stream, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.ConvertSurface(Surface* surface, PixelFormat format) => + int* ISdl.GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => ( - (delegate* unmanaged)( - _slots[47] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[234] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[47] = nativeContext.LoadFunction("SDL_ConvertSurface", "SDL3") + : _slots[234] = nativeContext.LoadFunction( + "SDL_GetAudioStreamOutputChannelMap", + "SDL3" + ) ) - )(surface, format); + )(stream, count); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* ConvertSurface(Surface* surface, PixelFormat format) => - DllImport.ConvertSurface(surface, format); + public static int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => + DllImport.GetAudioStreamOutputChannelMap(stream, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.ConvertSurface(Ref surface, PixelFormat format) + Ptr ISdl.GetAudioStreamOutputChannelMap(AudioStreamHandle stream, Ref count) { - fixed (Surface* __dsl_surface = surface) + fixed (int* __dsl_count = count) { - return (Surface*)((ISdl)this).ConvertSurface(__dsl_surface, format); + return (int*)((ISdl)this).GetAudioStreamOutputChannelMap(stream, __dsl_count); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr ConvertSurface(Ref surface, PixelFormat format) => - DllImport.ConvertSurface(surface, format); + public static Ptr GetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + Ref count + ) => DllImport.GetAudioStreamOutputChannelMap(stream, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.ConvertSurfaceAndColorspace( - Surface* surface, - PixelFormat format, - Palette* palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => + uint ISdl.GetAudioStreamProperties(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[48] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[235] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[48] = nativeContext.LoadFunction( - "SDL_ConvertSurfaceAndColorspace", + : _slots[235] = nativeContext.LoadFunction( + "SDL_GetAudioStreamProperties", "SDL3" ) ) - )(surface, format, palette, colorspace, props); + )(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* ConvertSurfaceAndColorspace( - Surface* surface, - PixelFormat format, - Palette* palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); + public static uint GetAudioStreamProperties(AudioStreamHandle stream) => + DllImport.GetAudioStreamProperties(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.ConvertSurfaceAndColorspace( - Ref surface, - PixelFormat format, - Ref palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) - { - fixed (Palette* __dsl_palette = palette) - fixed (Surface* __dsl_surface = surface) - { - return (Surface*) - ((ISdl)this).ConvertSurfaceAndColorspace( - __dsl_surface, - format, - __dsl_palette, - colorspace, - props - ); - } - } + int ISdl.GetAudioStreamQueued(AudioStreamHandle stream) => + ( + (delegate* unmanaged)( + _slots[236] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[236] = nativeContext.LoadFunction("SDL_GetAudioStreamQueued", "SDL3") + ) + )(stream); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int GetAudioStreamQueued(AudioStreamHandle stream) => + DllImport.GetAudioStreamQueued(stream); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetBasePath() => (sbyte*)((ISdl)this).GetBasePathRaw(); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetBasePath() => DllImport.GetBasePath(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetBasePathRaw() => + ( + (delegate* unmanaged)( + _slots[237] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[237] = nativeContext.LoadFunction("SDL_GetBasePath", "SDL3") + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ConvertSurfaceAndColorspace")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr ConvertSurfaceAndColorspace( - Ref surface, - PixelFormat format, - Ref palette, - Colorspace colorspace, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.ConvertSurfaceAndColorspace(surface, format, palette, colorspace, props); + public static sbyte* GetBasePathRaw() => DllImport.GetBasePathRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CopyFile( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath + byte ISdl.GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value ) => ( - (delegate* unmanaged)( - _slots[49] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[238] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[49] = nativeContext.LoadFunction("SDL_CopyFile", "SDL3") + : _slots[238] = nativeContext.LoadFunction("SDL_GetBooleanProperty", "SDL3") ) - )(oldpath, newpath); + )(props, name, default_value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CopyFile( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => DllImport.CopyFile(oldpath, newpath); + public static byte GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte default_value + ) => DllImport.GetBooleanProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CopyFile( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath + MaybeBool ISdl.GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value ) { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).CopyFile(__dsl_oldpath, __dsl_newpath); + return (MaybeBool) + (byte)((ISdl)this).GetBooleanProperty(props, __dsl_name, (byte)default_value); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CopyFile( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => DllImport.CopyFile(oldpath, newpath); + public static MaybeBool GetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool default_value + ) => DllImport.GetBooleanProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CopyProperties( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => (MaybeBool)(byte)((ISdl)this).CopyPropertiesRaw(src, dst); + Ptr ISdl.GetCameraDriver(int index) => (sbyte*)((ISdl)this).GetCameraDriverRaw(index); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CopyProperties( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => DllImport.CopyProperties(src, dst); + public static Ptr GetCameraDriver(int index) => DllImport.GetCameraDriver(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CopyPropertiesRaw( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => + sbyte* ISdl.GetCameraDriverRaw(int index) => ( - (delegate* unmanaged)( - _slots[50] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[239] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[50] = nativeContext.LoadFunction("SDL_CopyProperties", "SDL3") + : _slots[239] = nativeContext.LoadFunction("SDL_GetCameraDriver", "SDL3") ) - )(src, dst); + )(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyProperties")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CopyPropertiesRaw( - [NativeTypeName("SDL_PropertiesID")] uint src, - [NativeTypeName("SDL_PropertiesID")] uint dst - ) => DllImport.CopyPropertiesRaw(src, dst); + public static sbyte* GetCameraDriverRaw(int index) => DllImport.GetCameraDriverRaw(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => + byte ISdl.GetCameraFormat(CameraHandle camera, CameraSpec* spec) => ( - (delegate* unmanaged)( - _slots[51] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[240] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[51] = nativeContext.LoadFunction("SDL_CopyStorageFile", "SDL3") + : _slots[240] = nativeContext.LoadFunction("SDL_GetCameraFormat", "SDL3") ) - )(storage, oldpath, newpath); + )(camera, spec); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => DllImport.CopyStorageFile(storage, oldpath, newpath); + public static byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => + DllImport.GetCameraFormat(camera, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) + MaybeBool ISdl.GetCameraFormat(CameraHandle camera, Ref spec) { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) + fixed (CameraSpec* __dsl_spec = spec) { - return (MaybeBool) - (byte)((ISdl)this).CopyStorageFile(storage, __dsl_oldpath, __dsl_newpath); + return (MaybeBool)(byte)((ISdl)this).GetCameraFormat(camera, __dsl_spec); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CopyStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CopyStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => DllImport.CopyStorageFile(storage, oldpath, newpath); + public static MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) => + DllImport.GetCameraFormat(camera, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AudioStreamHandle ISdl.CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => + uint ISdl.GetCameraID(CameraHandle camera) => ( - (delegate* unmanaged)( - _slots[52] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[241] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[52] = nativeContext.LoadFunction("SDL_CreateAudioStream", "SDL3") + : _slots[241] = nativeContext.LoadFunction("SDL_GetCameraID", "SDL3") ) - )(src_spec, dst_spec); + )(camera); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [return: NativeTypeName("SDL_CameraID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => DllImport.CreateAudioStream(src_spec, dst_spec); + public static uint GetCameraID(CameraHandle camera) => DllImport.GetCameraID(camera); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AudioStreamHandle ISdl.CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) - { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (AudioStreamHandle) - ((ISdl)this).CreateAudioStream(__dsl_src_spec, __dsl_dst_spec); - } - } + Ptr ISdl.GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => + (sbyte*)((ISdl)this).GetCameraNameRaw(instance_id); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AudioStreamHandle CreateAudioStream( - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) => DllImport.CreateAudioStream(src_spec, dst_spec); + public static Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => + DllImport.GetCameraName(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.CreateColorCursor(Surface* surface, int hot_x, int hot_y) => + sbyte* ISdl.GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[53] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[242] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[53] = nativeContext.LoadFunction("SDL_CreateColorCursor", "SDL3") + : _slots[242] = nativeContext.LoadFunction("SDL_GetCameraName", "SDL3") ) - )(surface, hot_x, hot_y); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle CreateColorCursor(Surface* surface, int hot_x, int hot_y) => - DllImport.CreateColorCursor(surface, hot_x, hot_y); + public static sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => + DllImport.GetCameraNameRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.CreateColorCursor(Ref surface, int hot_x, int hot_y) - { - fixed (Surface* __dsl_surface = surface) - { - return (CursorHandle)((ISdl)this).CreateColorCursor(__dsl_surface, hot_x, hot_y); - } - } + int ISdl.GetCameraPermissionState(CameraHandle camera) => + ( + (delegate* unmanaged)( + _slots[243] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[243] = nativeContext.LoadFunction( + "SDL_GetCameraPermissionState", + "SDL3" + ) + ) + )(camera); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateColorCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle CreateColorCursor(Ref surface, int hot_x, int hot_y) => - DllImport.CreateColorCursor(surface, hot_x, hot_y); + public static int GetCameraPermissionState(CameraHandle camera) => + DllImport.GetCameraPermissionState(camera); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ConditionHandle ISdl.CreateCondition() => + CameraPosition ISdl.GetCameraPosition([NativeTypeName("SDL_CameraID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[54] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[244] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[54] = nativeContext.LoadFunction("SDL_CreateCondition", "SDL3") + : _slots[244] = nativeContext.LoadFunction("SDL_GetCameraPosition", "SDL3") ) - )(); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCondition")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ConditionHandle CreateCondition() => DllImport.CreateCondition(); + public static CameraPosition GetCameraPosition( + [NativeTypeName("SDL_CameraID")] uint instance_id + ) => DllImport.GetCameraPosition(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.CreateCursor( - [NativeTypeName("const Uint8 *")] byte* data, - [NativeTypeName("const Uint8 *")] byte* mask, - int w, - int h, - int hot_x, - int hot_y - ) => + uint ISdl.GetCameraProperties(CameraHandle camera) => ( - (delegate* unmanaged)( - _slots[55] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[245] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[55] = nativeContext.LoadFunction("SDL_CreateCursor", "SDL3") + : _slots[245] = nativeContext.LoadFunction("SDL_GetCameraProperties", "SDL3") ) - )(data, mask, w, h, hot_x, hot_y); + )(camera); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] byte* data, - [NativeTypeName("const Uint8 *")] byte* mask, - int w, - int h, - int hot_x, - int hot_y - ) => DllImport.CreateCursor(data, mask, w, h, hot_x, hot_y); + public static uint GetCameraProperties(CameraHandle camera) => + DllImport.GetCameraProperties(camera); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.CreateCursor( - [NativeTypeName("const Uint8 *")] Ref data, - [NativeTypeName("const Uint8 *")] Ref mask, - int w, - int h, - int hot_x, - int hot_y - ) + uint* ISdl.GetCameras(int* count) => + ( + (delegate* unmanaged)( + _slots[246] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[246] = nativeContext.LoadFunction("SDL_GetCameras", "SDL3") + ) + )(count); + + [return: NativeTypeName("SDL_CameraID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* GetCameras(int* count) => DllImport.GetCameras(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetCameras(Ref count) { - fixed (byte* __dsl_mask = mask) - fixed (byte* __dsl_data = data) + fixed (int* __dsl_count = count) { - return (CursorHandle) - ((ISdl)this).CreateCursor(__dsl_data, __dsl_mask, w, h, hot_x, hot_y); + return (uint*)((ISdl)this).GetCameras(__dsl_count); } } + [return: NativeTypeName("SDL_CameraID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle CreateCursor( - [NativeTypeName("const Uint8 *")] Ref data, - [NativeTypeName("const Uint8 *")] Ref mask, - int w, - int h, - int hot_x, - int hot_y - ) => DllImport.CreateCursor(data, mask, w, h, hot_x, hot_y); + public static Ptr GetCameras(Ref count) => DllImport.GetCameras(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CreateDirectory([NativeTypeName("const char *")] sbyte* path) => + CameraSpec** ISdl.GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + int* count + ) => ( - (delegate* unmanaged)( - _slots[56] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[247] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[56] = nativeContext.LoadFunction("SDL_CreateDirectory", "SDL3") + : _slots[247] = nativeContext.LoadFunction( + "SDL_GetCameraSupportedFormats", + "SDL3" + ) ) - )(path); + )(devid, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CreateDirectory([NativeTypeName("const char *")] sbyte* path) => - DllImport.CreateDirectory(path); + public static CameraSpec** GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + int* count + ) => DllImport.GetCameraSupportedFormats(devid, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CreateDirectory([NativeTypeName("const char *")] Ref path) + Ptr2D ISdl.GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + Ref count + ) { - fixed (sbyte* __dsl_path = path) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)((ISdl)this).CreateDirectory(__dsl_path); + return (CameraSpec**)((ISdl)this).GetCameraSupportedFormats(devid, __dsl_count); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CreateDirectory( - [NativeTypeName("const char *")] Ref path - ) => DllImport.CreateDirectory(path); + public static Ptr2D GetCameraSupportedFormats( + [NativeTypeName("SDL_CameraID")] uint devid, + Ref count + ) => DllImport.GetCameraSupportedFormats(devid, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + void* ISdl.GetClipboardData( + [NativeTypeName("const char *")] sbyte* mime_type, + [NativeTypeName("size_t *")] nuint* size ) => ( - (delegate* unmanaged)( - _slots[57] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[248] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[57] = nativeContext.LoadFunction("SDL_CreateHapticEffect", "SDL3") + : _slots[248] = nativeContext.LoadFunction("SDL_GetClipboardData", "SDL3") ) - )(haptic, effect); + )(mime_type, size); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => DllImport.CreateHapticEffect(haptic, effect); + public static void* GetClipboardData( + [NativeTypeName("const char *")] sbyte* mime_type, + [NativeTypeName("size_t *")] nuint* size + ) => DllImport.GetClipboardData(mime_type, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect + Ptr ISdl.GetClipboardData( + [NativeTypeName("const char *")] Ref mime_type, + [NativeTypeName("size_t *")] Ref size ) { - fixed (HapticEffect* __dsl_effect = effect) + fixed (nuint* __dsl_size = size) + fixed (sbyte* __dsl_mime_type = mime_type) { - return (int)((ISdl)this).CreateHapticEffect(haptic, __dsl_effect); + return (void*)((ISdl)this).GetClipboardData(__dsl_mime_type, __dsl_size); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int CreateHapticEffect( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) => DllImport.CreateHapticEffect(haptic, effect); + public static Ptr GetClipboardData( + [NativeTypeName("const char *")] Ref mime_type, + [NativeTypeName("size_t *")] Ref size + ) => DllImport.GetClipboardData(mime_type, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MutexHandle ISdl.CreateMutex() => + sbyte** ISdl.GetClipboardMimeTypes([NativeTypeName("size_t *")] nuint* num_mime_types) => ( - (delegate* unmanaged)( - _slots[58] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[249] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[58] = nativeContext.LoadFunction("SDL_CreateMutex", "SDL3") + : _slots[249] = nativeContext.LoadFunction("SDL_GetClipboardMimeTypes", "SDL3") ) - )(); + )(num_mime_types); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateMutex")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MutexHandle CreateMutex() => DllImport.CreateMutex(); + public static sbyte** GetClipboardMimeTypes( + [NativeTypeName("size_t *")] nuint* num_mime_types + ) => DllImport.GetClipboardMimeTypes(num_mime_types); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreatePalette(int ncolors) => - (Palette*)((ISdl)this).CreatePaletteRaw(ncolors); + Ptr2D ISdl.GetClipboardMimeTypes([NativeTypeName("size_t *")] Ref num_mime_types) + { + fixed (nuint* __dsl_num_mime_types = num_mime_types) + { + return (sbyte**)((ISdl)this).GetClipboardMimeTypes(__dsl_num_mime_types); + } + } + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreatePalette(int ncolors) => DllImport.CreatePalette(ncolors); + public static Ptr2D GetClipboardMimeTypes( + [NativeTypeName("size_t *")] Ref num_mime_types + ) => DllImport.GetClipboardMimeTypes(num_mime_types); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Palette* ISdl.CreatePaletteRaw(int ncolors) => + Ptr ISdl.GetClipboardText() => (sbyte*)((ISdl)this).GetClipboardTextRaw(); + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetClipboardText() => DllImport.GetClipboardText(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetClipboardTextRaw() => ( - (delegate* unmanaged)( - _slots[59] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[250] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[59] = nativeContext.LoadFunction("SDL_CreatePalette", "SDL3") + : _slots[250] = nativeContext.LoadFunction("SDL_GetClipboardText", "SDL3") ) - )(ncolors); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePalette")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Palette* CreatePaletteRaw(int ncolors) => DllImport.CreatePaletteRaw(ncolors); + public static sbyte* GetClipboardTextRaw() => DllImport.GetClipboardTextRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.CreatePopupWindow( - WindowHandle parent, - int offset_x, - int offset_y, + byte ISdl.GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, int w, int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags + float refresh_rate, + [NativeTypeName("bool")] byte include_high_density_modes, + DisplayMode* mode ) => ( - (delegate* unmanaged)( - _slots[60] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[251] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[60] = nativeContext.LoadFunction("SDL_CreatePopupWindow", "SDL3") + : _slots[251] = nativeContext.LoadFunction( + "SDL_GetClosestFullscreenDisplayMode", + "SDL3" + ) ) - )(parent, offset_x, offset_y, w, h, flags); + )(displayID, w, h, refresh_rate, include_high_density_modes, mode); - [NativeFunction("SDL3", EntryPoint = "SDL_CreatePopupWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle CreatePopupWindow( - WindowHandle parent, - int offset_x, - int offset_y, + public static byte GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] byte include_high_density_modes, + DisplayMode* mode + ) => + DllImport.GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + include_high_density_modes, + mode + ); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int w, + int h, + float refresh_rate, + [NativeTypeName("bool")] MaybeBool include_high_density_modes, + Ref mode + ) + { + fixed (DisplayMode* __dsl_mode = mode) + { + return (MaybeBool) + (byte) + ((ISdl)this).GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + (byte)include_high_density_modes, + __dsl_mode + ); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetClosestFullscreenDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID, int w, int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => DllImport.CreatePopupWindow(parent, offset_x, offset_y, w, h, flags); + float refresh_rate, + [NativeTypeName("bool")] MaybeBool include_high_density_modes, + Ref mode + ) => + DllImport.GetClosestFullscreenDisplayMode( + displayID, + w, + h, + refresh_rate, + include_high_density_modes, + mode + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.CreateProperties() => + int ISdl.GetCPUCacheLineSize() => ( - (delegate* unmanaged)( - _slots[61] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[252] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[61] = nativeContext.LoadFunction("SDL_CreateProperties", "SDL3") + : _slots[252] = nativeContext.LoadFunction("SDL_GetCPUCacheLineSize", "SDL3") ) )(); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint CreateProperties() => DllImport.CreateProperties(); + public static int GetCPUCacheLineSize() => DllImport.GetCPUCacheLineSize(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* name - ) => + Ptr ISdl.GetCurrentAudioDriver() => (sbyte*)((ISdl)this).GetCurrentAudioDriverRaw(); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetCurrentAudioDriver() => DllImport.GetCurrentAudioDriver(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetCurrentAudioDriverRaw() => ( - (delegate* unmanaged)( - _slots[62] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[253] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[62] = nativeContext.LoadFunction("SDL_CreateRenderer", "SDL3") + : _slots[253] = nativeContext.LoadFunction("SDL_GetCurrentAudioDriver", "SDL3") ) - )(window, name); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.CreateRenderer(window, name); + public static sbyte* GetCurrentAudioDriverRaw() => DllImport.GetCurrentAudioDriverRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (RendererHandle)((ISdl)this).CreateRenderer(window, __dsl_name); - } - } + Ptr ISdl.GetCurrentCameraDriver() => (sbyte*)((ISdl)this).GetCurrentCameraDriverRaw(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle CreateRenderer( - WindowHandle window, - [NativeTypeName("const char *")] Ref name - ) => DllImport.CreateRenderer(window, name); + public static Ptr GetCurrentCameraDriver() => DllImport.GetCurrentCameraDriver(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.CreateRendererWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => + sbyte* ISdl.GetCurrentCameraDriverRaw() => ( - (delegate* unmanaged)( - _slots[63] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[254] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[63] = nativeContext.LoadFunction( - "SDL_CreateRendererWithProperties", - "SDL3" - ) + : _slots[254] = nativeContext.LoadFunction("SDL_GetCurrentCameraDriver", "SDL3") ) - )(props); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRendererWithProperties")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle CreateRendererWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.CreateRendererWithProperties(props); + public static sbyte* GetCurrentCameraDriverRaw() => DllImport.GetCurrentCameraDriverRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RWLockHandle ISdl.CreateRWLock() => + Ptr ISdl.GetCurrentDisplayMode([NativeTypeName("SDL_DisplayID")] uint displayID) => + (DisplayMode*)((ISdl)this).GetCurrentDisplayModeRaw(displayID); + + [return: NativeTypeName("const SDL_DisplayMode *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetCurrentDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetCurrentDisplayMode(displayID); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + DisplayMode* ISdl.GetCurrentDisplayModeRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => ( - (delegate* unmanaged)( - _slots[64] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[255] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[64] = nativeContext.LoadFunction("SDL_CreateRWLock", "SDL3") + : _slots[255] = nativeContext.LoadFunction("SDL_GetCurrentDisplayMode", "SDL3") ) - )(); + )(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateRWLock")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RWLockHandle CreateRWLock() => DllImport.CreateRWLock(); + public static DisplayMode* GetCurrentDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetCurrentDisplayModeRaw(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SemaphoreHandle ISdl.CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => + DisplayOrientation ISdl.GetCurrentDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => ( - (delegate* unmanaged)( - _slots[65] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[256] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[65] = nativeContext.LoadFunction("SDL_CreateSemaphore", "SDL3") + : _slots[256] = nativeContext.LoadFunction( + "SDL_GetCurrentDisplayOrientation", + "SDL3" + ) ) - )(initial_value); + )(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SemaphoreHandle CreateSemaphore([NativeTypeName("Uint32")] uint initial_value) => - DllImport.CreateSemaphore(initial_value); + public static DisplayOrientation GetCurrentDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetCurrentDisplayOrientation(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.CreateSoftwareRenderer(Surface* surface) => + byte ISdl.GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[66] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[257] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[66] = nativeContext.LoadFunction("SDL_CreateSoftwareRenderer", "SDL3") + : _slots[257] = nativeContext.LoadFunction( + "SDL_GetCurrentRenderOutputSize", + "SDL3" + ) ) - )(surface); + )(renderer, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle CreateSoftwareRenderer(Surface* surface) => - DllImport.CreateSoftwareRenderer(surface); + public static byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => + DllImport.GetCurrentRenderOutputSize(renderer, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.CreateSoftwareRenderer(Ref surface) + MaybeBool ISdl.GetCurrentRenderOutputSize(RendererHandle renderer, Ref w, Ref h) { - fixed (Surface* __dsl_surface = surface) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (RendererHandle)((ISdl)this).CreateSoftwareRenderer(__dsl_surface); + return (MaybeBool) + (byte)((ISdl)this).GetCurrentRenderOutputSize(renderer, __dsl_w, __dsl_h); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSoftwareRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle CreateSoftwareRenderer(Ref surface) => - DllImport.CreateSoftwareRenderer(surface); + public static MaybeBool GetCurrentRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h + ) => DllImport.GetCurrentRenderOutputSize(renderer, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => + ulong ISdl.GetCurrentThreadID() => ( - (delegate* unmanaged)( - _slots[67] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[258] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[67] = nativeContext.LoadFunction("SDL_CreateStorageDirectory", "SDL3") + : _slots[258] = nativeContext.LoadFunction("SDL_GetCurrentThreadID", "SDL3") ) - )(storage, path); + )(); + + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static ulong GetCurrentThreadID() => DllImport.GetCurrentThreadID(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => + ( + (delegate* unmanaged)( + _slots[259] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[259] = nativeContext.LoadFunction("SDL_GetCurrentTime", "SDL3") + ) + )(ticks); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => DllImport.CreateStorageDirectory(storage, path); + public static byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => + DllImport.GetCurrentTime(ticks); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) + MaybeBool ISdl.GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) { - fixed (sbyte* __dsl_path = path) + fixed (long* __dsl_ticks = ticks) { - return (MaybeBool)(byte)((ISdl)this).CreateStorageDirectory(storage, __dsl_path); + return (MaybeBool)(byte)((ISdl)this).GetCurrentTime(__dsl_ticks); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CreateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) => DllImport.CreateStorageDirectory(storage, path); + public static MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) => + DllImport.GetCurrentTime(ticks); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateSurface(int width, int height, PixelFormat format) => - (Surface*)((ISdl)this).CreateSurfaceRaw(width, height, format); + Ptr ISdl.GetCurrentVideoDriver() => (sbyte*)((ISdl)this).GetCurrentVideoDriverRaw(); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateSurface(int width, int height, PixelFormat format) => - DllImport.CreateSurface(width, height, format); + public static Ptr GetCurrentVideoDriver() => DllImport.GetCurrentVideoDriver(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - void* pixels, - int pitch - ) => + sbyte* ISdl.GetCurrentVideoDriverRaw() => ( - (delegate* unmanaged)( - _slots[69] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[260] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[69] = nativeContext.LoadFunction("SDL_CreateSurfaceFrom", "SDL3") + : _slots[260] = nativeContext.LoadFunction("SDL_GetCurrentVideoDriver", "SDL3") ) - )(width, height, format, pixels, pitch); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - void* pixels, - int pitch - ) => DllImport.CreateSurfaceFrom(width, height, format, pixels, pitch); + public static sbyte* GetCurrentVideoDriverRaw() => DllImport.GetCurrentVideoDriverRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - Ref pixels, - int pitch - ) - { - fixed (void* __dsl_pixels = pixels) - { - return (Surface*) - ((ISdl)this).CreateSurfaceFrom(width, height, format, __dsl_pixels, pitch); - } - } + CursorHandle ISdl.GetCursor() => + ( + (delegate* unmanaged)( + _slots[261] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[261] = nativeContext.LoadFunction("SDL_GetCursor", "SDL3") + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfaceFrom")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateSurfaceFrom( - int width, - int height, - PixelFormat format, - Ref pixels, - int pitch - ) => DllImport.CreateSurfaceFrom(width, height, format, pixels, pitch); + public static CursorHandle GetCursor() => DllImport.GetCursor(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Palette* ISdl.CreateSurfacePalette(Surface* surface) => + byte ISdl.GetDateTimeLocalePreferences(DateFormat* dateFormat, TimeFormat* timeFormat) => ( - (delegate* unmanaged)( - _slots[70] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[262] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[70] = nativeContext.LoadFunction("SDL_CreateSurfacePalette", "SDL3") + : _slots[262] = nativeContext.LoadFunction( + "SDL_GetDateTimeLocalePreferences", + "SDL3" + ) ) - )(surface); + )(dateFormat, timeFormat); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Palette* CreateSurfacePalette(Surface* surface) => - DllImport.CreateSurfacePalette(surface); + public static byte GetDateTimeLocalePreferences( + DateFormat* dateFormat, + TimeFormat* timeFormat + ) => DllImport.GetDateTimeLocalePreferences(dateFormat, timeFormat); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateSurfacePalette(Ref surface) + MaybeBool ISdl.GetDateTimeLocalePreferences( + Ref dateFormat, + Ref timeFormat + ) { - fixed (Surface* __dsl_surface = surface) + fixed (TimeFormat* __dsl_timeFormat = timeFormat) + fixed (DateFormat* __dsl_dateFormat = dateFormat) { - return (Palette*)((ISdl)this).CreateSurfacePalette(__dsl_surface); + return (MaybeBool) + (byte)((ISdl)this).GetDateTimeLocalePreferences(__dsl_dateFormat, __dsl_timeFormat); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateSurfacePalette(Ref surface) => - DllImport.CreateSurfacePalette(surface); + public static MaybeBool GetDateTimeLocalePreferences( + Ref dateFormat, + Ref timeFormat + ) => DllImport.GetDateTimeLocalePreferences(dateFormat, timeFormat); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.CreateSurfaceRaw(int width, int height, PixelFormat format) => + int ISdl.GetDayOfWeek(int year, int month, int day) => ( - (delegate* unmanaged)( - _slots[68] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[263] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[68] = nativeContext.LoadFunction("SDL_CreateSurface", "SDL3") + : _slots[263] = nativeContext.LoadFunction("SDL_GetDayOfWeek", "SDL3") ) - )(width, height, format); + )(year, month, day); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* CreateSurfaceRaw(int width, int height, PixelFormat format) => - DllImport.CreateSurfaceRaw(width, height, format); + public static int GetDayOfWeek(int year, int month, int day) => + DllImport.GetDayOfWeek(year, month, day); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.CreateSystemCursor(SystemCursor id) => + int ISdl.GetDayOfYear(int year, int month, int day) => ( - (delegate* unmanaged)( - _slots[71] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[264] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[71] = nativeContext.LoadFunction("SDL_CreateSystemCursor", "SDL3") + : _slots[264] = nativeContext.LoadFunction("SDL_GetDayOfYear", "SDL3") ) - )(id); + )(year, month, day); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateSystemCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle CreateSystemCursor(SystemCursor id) => - DllImport.CreateSystemCursor(id); + public static int GetDayOfYear(int year, int month, int day) => + DllImport.GetDayOfYear(year, month, day); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateTexture( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => (Texture*)((ISdl)this).CreateTextureRaw(renderer, format, access, w, h); + int ISdl.GetDaysInMonth(int year, int month) => + ( + (delegate* unmanaged)( + _slots[265] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[265] = nativeContext.LoadFunction("SDL_GetDaysInMonth", "SDL3") + ) + )(year, month); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateTexture( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => DllImport.CreateTexture(renderer, format, access, w, h); + public static int GetDaysInMonth(int year, int month) => DllImport.GetDaysInMonth(year, month); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Texture* ISdl.CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => + AssertionHandler ISdl.GetDefaultAssertionHandler() => ( - (delegate* unmanaged)( - _slots[73] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[266] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[73] = nativeContext.LoadFunction( - "SDL_CreateTextureFromSurface", + : _slots[266] = nativeContext.LoadFunction( + "SDL_GetDefaultAssertionHandler", "SDL3" ) ) - )(renderer, surface); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [return: NativeTypeName("SDL_AssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Texture* CreateTextureFromSurface(RendererHandle renderer, Surface* surface) => - DllImport.CreateTextureFromSurface(renderer, surface); + public static AssertionHandler GetDefaultAssertionHandler() => + DllImport.GetDefaultAssertionHandler(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateTextureFromSurface(RendererHandle renderer, Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (Texture*)((ISdl)this).CreateTextureFromSurface(renderer, __dsl_surface); - } - } + CursorHandle ISdl.GetDefaultCursor() => + ( + (delegate* unmanaged)( + _slots[267] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[267] = nativeContext.LoadFunction("SDL_GetDefaultCursor", "SDL3") + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureFromSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateTextureFromSurface( - RendererHandle renderer, - Ref surface - ) => DllImport.CreateTextureFromSurface(renderer, surface); + public static CursorHandle GetDefaultCursor() => DllImport.GetDefaultCursor(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Texture* ISdl.CreateTextureRaw( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => + LogOutputFunction ISdl.GetDefaultLogOutputFunction() => ( - (delegate* unmanaged)( - _slots[72] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[268] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[72] = nativeContext.LoadFunction("SDL_CreateTexture", "SDL3") + : _slots[268] = nativeContext.LoadFunction( + "SDL_GetDefaultLogOutputFunction", + "SDL3" + ) ) - )(renderer, format, access, w, h); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTexture")] + [return: NativeTypeName("SDL_LogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Texture* CreateTextureRaw( - RendererHandle renderer, - PixelFormat format, - TextureAccess access, - int w, - int h - ) => DllImport.CreateTextureRaw(renderer, format, access, w, h); + public static LogOutputFunction GetDefaultLogOutputFunction() => + DllImport.GetDefaultLogOutputFunction(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.CreateTextureWithProperties( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => (Texture*)((ISdl)this).CreateTextureWithPropertiesRaw(renderer, props); + Ptr ISdl.GetDesktopDisplayMode([NativeTypeName("SDL_DisplayID")] uint displayID) => + (DisplayMode*)((ISdl)this).GetDesktopDisplayModeRaw(displayID); + [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr CreateTextureWithProperties( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.CreateTextureWithProperties(renderer, props); + public static Ptr GetDesktopDisplayMode( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetDesktopDisplayMode(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Texture* ISdl.CreateTextureWithPropertiesRaw( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => + DisplayMode* ISdl.GetDesktopDisplayModeRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => ( - (delegate* unmanaged)( - _slots[74] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[269] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[74] = nativeContext.LoadFunction( - "SDL_CreateTextureWithProperties", - "SDL3" - ) + : _slots[269] = nativeContext.LoadFunction("SDL_GetDesktopDisplayMode", "SDL3") ) - )(renderer, props); + )(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateTextureWithProperties")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Texture* CreateTextureWithPropertiesRaw( - RendererHandle renderer, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.CreateTextureWithPropertiesRaw(renderer, props); + public static DisplayMode* GetDesktopDisplayModeRaw( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetDesktopDisplayModeRaw(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ThreadHandle ISdl.CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] sbyte* name, - void* data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => + byte ISdl.GetDisplayBounds([NativeTypeName("SDL_DisplayID")] uint displayID, Rect* rect) => ( - (delegate* unmanaged< - ThreadFunction, - sbyte*, - void*, - FunctionPointer, - FunctionPointer, - ThreadHandle>)( - _slots[75] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[270] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[75] = nativeContext.LoadFunction("SDL_CreateThreadRuntime", "SDL3") + : _slots[270] = nativeContext.LoadFunction("SDL_GetDisplayBounds", "SDL3") ) - )(fn, name, data, pfnBeginThread, pfnEndThread); + )(displayID, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] sbyte* name, - void* data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => DllImport.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); + public static byte GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => DllImport.GetDisplayBounds(displayID, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ThreadHandle ISdl.CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] Ref name, - Ref data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread + MaybeBool ISdl.GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect ) { - fixed (void* __dsl_data = data) - fixed (sbyte* __dsl_name = name) + fixed (Rect* __dsl_rect = rect) { - return (ThreadHandle) - ((ISdl)this).CreateThreadRuntime( - fn, - __dsl_name, - __dsl_data, - pfnBeginThread, - pfnEndThread - ); + return (MaybeBool)(byte)((ISdl)this).GetDisplayBounds(displayID, __dsl_rect); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadRuntime")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ThreadHandle CreateThreadRuntime( - [NativeTypeName("SDL_ThreadFunction")] ThreadFunction fn, - [NativeTypeName("const char *")] Ref name, - Ref data, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => DllImport.CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); + public static MaybeBool GetDisplayBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) => DllImport.GetDisplayBounds(displayID, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ThreadHandle ISdl.CreateThreadWithPropertiesRuntime( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => + float ISdl.GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => ( - (delegate* unmanaged)( - _slots[76] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[271] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[76] = nativeContext.LoadFunction( - "SDL_CreateThreadWithPropertiesRuntime", - "SDL3" - ) + : _slots[271] = nativeContext.LoadFunction("SDL_GetDisplayContentScale", "SDL3") ) - )(props, pfnBeginThread, pfnEndThread); + )(displayID); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateThreadWithPropertiesRuntime")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ThreadHandle CreateThreadWithPropertiesRuntime( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnBeginThread, - [NativeTypeName("SDL_FunctionPointer")] FunctionPointer pfnEndThread - ) => DllImport.CreateThreadWithPropertiesRuntime(props, pfnBeginThread, pfnEndThread); + public static float GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => + DllImport.GetDisplayContentScale(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.CreateWindow( - [NativeTypeName("const char *")] sbyte* title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => + uint ISdl.GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => ( - (delegate* unmanaged)( - _slots[77] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[272] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[77] = nativeContext.LoadFunction("SDL_CreateWindow", "SDL3") + : _slots[272] = nativeContext.LoadFunction("SDL_GetDisplayForPoint", "SDL3") ) - )(title, w, h, flags); + )(point); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle CreateWindow( - [NativeTypeName("const char *")] sbyte* title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => DllImport.CreateWindow(title, w, h, flags); + public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => + DllImport.GetDisplayForPoint(point); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.CreateWindow( - [NativeTypeName("const char *")] Ref title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) + uint ISdl.GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) { - fixed (sbyte* __dsl_title = title) + fixed (Point* __dsl_point = point) { - return (WindowHandle)((ISdl)this).CreateWindow(__dsl_title, w, h, flags); + return (uint)((ISdl)this).GetDisplayForPoint(__dsl_point); } } + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle CreateWindow( - [NativeTypeName("const char *")] Ref title, - int w, - int h, - [NativeTypeName("SDL_WindowFlags")] ulong flags - ) => DllImport.CreateWindow(title, w, h, flags); + public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) => + DllImport.GetDisplayForPoint(point); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CreateWindowAndRenderer( - [NativeTypeName("const char *")] sbyte* title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - WindowHandle* window, - RendererHandle* renderer - ) => + uint ISdl.GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => ( - (delegate* unmanaged)( - _slots[78] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[273] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[78] = nativeContext.LoadFunction("SDL_CreateWindowAndRenderer", "SDL3") + : _slots[273] = nativeContext.LoadFunction("SDL_GetDisplayForRect", "SDL3") ) - )(title, width, height, window_flags, window, renderer); + )(rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CreateWindowAndRenderer( - [NativeTypeName("const char *")] sbyte* title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - WindowHandle* window, - RendererHandle* renderer - ) => DllImport.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); + public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => + DllImport.GetDisplayForRect(rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CreateWindowAndRenderer( - [NativeTypeName("const char *")] Ref title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - Ref window, - Ref renderer - ) + uint ISdl.GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) { - fixed (RendererHandle* __dsl_renderer = renderer) - fixed (WindowHandle* __dsl_window = window) - fixed (sbyte* __dsl_title = title) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte) - ((ISdl)this).CreateWindowAndRenderer( - __dsl_title, - width, - height, - window_flags, - __dsl_window, - __dsl_renderer - ); + return (uint)((ISdl)this).GetDisplayForRect(__dsl_rect); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowAndRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CreateWindowAndRenderer( - [NativeTypeName("const char *")] Ref title, - int width, - int height, - [NativeTypeName("SDL_WindowFlags")] ulong window_flags, - Ref window, - Ref renderer - ) => DllImport.CreateWindowAndRenderer(title, width, height, window_flags, window, renderer); + public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) => + DllImport.GetDisplayForRect(rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.CreateWindowWithProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + uint ISdl.GetDisplayForWindow(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[79] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[274] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[79] = nativeContext.LoadFunction( - "SDL_CreateWindowWithProperties", - "SDL3" - ) + : _slots[274] = nativeContext.LoadFunction("SDL_GetDisplayForWindow", "SDL3") ) - )(props); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_CreateWindowWithProperties")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle CreateWindowWithProperties( - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.CreateWindowWithProperties(props); + public static uint GetDisplayForWindow(WindowHandle window) => + DllImport.GetDisplayForWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.CursorVisible() => (MaybeBool)(byte)((ISdl)this).CursorVisibleRaw(); + Ptr ISdl.GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => + (sbyte*)((ISdl)this).GetDisplayNameRaw(displayID); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool CursorVisible() => DllImport.CursorVisible(); + public static Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => + DllImport.GetDisplayName(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.CursorVisibleRaw() => + sbyte* ISdl.GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => ( - (delegate* unmanaged)( - _slots[80] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[275] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[80] = nativeContext.LoadFunction("SDL_CursorVisible", "SDL3") + : _slots[275] = nativeContext.LoadFunction("SDL_GetDisplayName", "SDL3") ) - )(); + )(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_CursorVisible")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte CursorVisibleRaw() => DllImport.CursorVisibleRaw(); + public static sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => + DllImport.GetDisplayNameRaw(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] DateTime* dt, - [NativeTypeName("SDL_Time *")] long* ticks - ) => + uint ISdl.GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => ( - (delegate* unmanaged)( - _slots[81] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[276] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[81] = nativeContext.LoadFunction("SDL_DateTimeToTime", "SDL3") + : _slots[276] = nativeContext.LoadFunction("SDL_GetDisplayProperties", "SDL3") ) - )(dt, ticks); + )(displayID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] DateTime* dt, - [NativeTypeName("SDL_Time *")] long* ticks - ) => DllImport.DateTimeToTime(dt, ticks); + public static uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => + DllImport.GetDisplayProperties(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] Ref dt, - [NativeTypeName("SDL_Time *")] Ref ticks - ) + uint* ISdl.GetDisplays(int* count) => + ( + (delegate* unmanaged)( + _slots[277] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[277] = nativeContext.LoadFunction("SDL_GetDisplays", "SDL3") + ) + )(count); + + [return: NativeTypeName("SDL_DisplayID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* GetDisplays(int* count) => DllImport.GetDisplays(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetDisplays(Ref count) { - fixed (long* __dsl_ticks = ticks) - fixed (DateTime* __dsl_dt = dt) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)((ISdl)this).DateTimeToTime(__dsl_dt, __dsl_ticks); + return (uint*)((ISdl)this).GetDisplays(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_DisplayID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DateTimeToTime")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool DateTimeToTime( - [NativeTypeName("const SDL_DateTime *")] Ref dt, - [NativeTypeName("SDL_Time *")] Ref ticks - ) => DllImport.DateTimeToTime(dt, ticks); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.Delay([NativeTypeName("Uint32")] uint ms) => - ( - (delegate* unmanaged)( - _slots[82] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[82] = nativeContext.LoadFunction("SDL_Delay", "SDL3") - ) - )(ms); - - [NativeFunction("SDL3", EntryPoint = "SDL_Delay")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void Delay([NativeTypeName("Uint32")] uint ms) => DllImport.Delay(ms); + public static Ptr GetDisplays(Ref count) => DllImport.GetDisplays(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DelayNS([NativeTypeName("Uint64")] ulong ns) => + byte ISdl.GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => ( - (delegate* unmanaged)( - _slots[83] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[278] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[83] = nativeContext.LoadFunction("SDL_DelayNS", "SDL3") + : _slots[278] = nativeContext.LoadFunction("SDL_GetDisplayUsableBounds", "SDL3") ) - )(ns); + )(displayID, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_DelayNS")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DelayNS([NativeTypeName("Uint64")] ulong ns) => DllImport.DelayNS(ns); + public static byte GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Rect* rect + ) => DllImport.GetDisplayUsableBounds(displayID, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DelayPrecise([NativeTypeName("Uint64")] ulong ns) => - ( - (delegate* unmanaged)( - _slots[84] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[84] = nativeContext.LoadFunction("SDL_DelayPrecise", "SDL3") - ) - )(ns); + MaybeBool ISdl.GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool) + (byte)((ISdl)this).GetDisplayUsableBounds(displayID, __dsl_rect); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_DelayPrecise")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DelayPrecise([NativeTypeName("Uint64")] ulong ns) => - DllImport.DelayPrecise(ns); + public static MaybeBool GetDisplayUsableBounds( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref rect + ) => DllImport.GetDisplayUsableBounds(displayID, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyAudioStream(AudioStreamHandle stream) => + sbyte* ISdl.Getenv([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[85] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[279] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[85] = nativeContext.LoadFunction("SDL_DestroyAudioStream", "SDL3") + : _slots[279] = nativeContext.LoadFunction("SDL_getenv", "SDL3") ) - )(stream); + )(name); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyAudioStream")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyAudioStream(AudioStreamHandle stream) => - DllImport.DestroyAudioStream(stream); + public static sbyte* Getenv([NativeTypeName("const char *")] sbyte* name) => + DllImport.Getenv(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyCondition(ConditionHandle cond) => - ( - (delegate* unmanaged)( - _slots[86] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[86] = nativeContext.LoadFunction("SDL_DestroyCondition", "SDL3") - ) - )(cond); + Ptr ISdl.Getenv([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)((ISdl)this).Getenv(__dsl_name); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCondition")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyCondition(ConditionHandle cond) => DllImport.DestroyCondition(cond); + public static Ptr Getenv([NativeTypeName("const char *")] Ref name) => + DllImport.Getenv(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyCursor(CursorHandle cursor) => + sbyte* ISdl.GetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[87] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[280] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[87] = nativeContext.LoadFunction("SDL_DestroyCursor", "SDL3") + : _slots[280] = nativeContext.LoadFunction("SDL_getenv_unsafe", "SDL3") ) - )(cursor); + )(name); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyCursor")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyCursor(CursorHandle cursor) => DllImport.DestroyCursor(cursor); + public static sbyte* GetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + DllImport.GetenvUnsafe(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyHapticEffect(HapticHandle haptic, int effect) => - ( - (delegate* unmanaged)( - _slots[88] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[88] = nativeContext.LoadFunction("SDL_DestroyHapticEffect", "SDL3") - ) - )(haptic, effect); + Ptr ISdl.GetenvUnsafe([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (sbyte*)((ISdl)this).GetenvUnsafe(__dsl_name); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyHapticEffect")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_getenv_unsafe")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyHapticEffect(HapticHandle haptic, int effect) => - DllImport.DestroyHapticEffect(haptic, effect); + public static Ptr GetenvUnsafe([NativeTypeName("const char *")] Ref name) => + DllImport.GetenvUnsafe(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyMutex(MutexHandle mutex) => + EnvironmentHandle ISdl.GetEnvironment() => ( - (delegate* unmanaged)( - _slots[89] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[281] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[89] = nativeContext.LoadFunction("SDL_DestroyMutex", "SDL3") + : _slots[281] = nativeContext.LoadFunction("SDL_GetEnvironment", "SDL3") ) - )(mutex); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironment")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyMutex(MutexHandle mutex) => DllImport.DestroyMutex(mutex); + public static EnvironmentHandle GetEnvironment() => DllImport.GetEnvironment(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyPalette(Palette* palette) => + sbyte* ISdl.GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => ( - (delegate* unmanaged)( - _slots[90] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[282] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[90] = nativeContext.LoadFunction("SDL_DestroyPalette", "SDL3") + : _slots[282] = nativeContext.LoadFunction("SDL_GetEnvironmentVariable", "SDL3") ) - )(palette); + )(env, name); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyPalette(Palette* palette) => DllImport.DestroyPalette(palette); + public static sbyte* GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.GetEnvironmentVariable(env, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyPalette(Ref palette) + Ptr ISdl.GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) { - fixed (Palette* __dsl_palette = palette) + fixed (sbyte* __dsl_name = name) { - ((ISdl)this).DestroyPalette(__dsl_palette); + return (sbyte*)((ISdl)this).GetEnvironmentVariable(env, __dsl_name); } } + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyPalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyPalette(Ref palette) => DllImport.DestroyPalette(palette); + public static Ptr GetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) => DllImport.GetEnvironmentVariable(env, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - ( - (delegate* unmanaged)( - _slots[91] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[91] = nativeContext.LoadFunction("SDL_DestroyProperties", "SDL3") - ) - )(props); + Ptr2D ISdl.GetEnvironmentVariables(EnvironmentHandle env) => + (sbyte**)((ISdl)this).GetEnvironmentVariablesRaw(env); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyProperties")] + [return: NativeTypeName("char **")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - DllImport.DestroyProperties(props); + public static Ptr2D GetEnvironmentVariables(EnvironmentHandle env) => + DllImport.GetEnvironmentVariables(env); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyRenderer(RendererHandle renderer) => + sbyte** ISdl.GetEnvironmentVariablesRaw(EnvironmentHandle env) => ( - (delegate* unmanaged)( - _slots[92] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[283] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[92] = nativeContext.LoadFunction("SDL_DestroyRenderer", "SDL3") + : _slots[283] = nativeContext.LoadFunction( + "SDL_GetEnvironmentVariables", + "SDL3" + ) ) - )(renderer); + )(env); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRenderer")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEnvironmentVariables")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyRenderer(RendererHandle renderer) => - DllImport.DestroyRenderer(renderer); + public static sbyte** GetEnvironmentVariablesRaw(EnvironmentHandle env) => + DllImport.GetEnvironmentVariablesRaw(env); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyRWLock(RWLockHandle rwlock) => - ( - (delegate* unmanaged)( - _slots[93] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[93] = nativeContext.LoadFunction("SDL_DestroyRWLock", "SDL3") - ) - )(rwlock); + Ptr ISdl.GetError() => (sbyte*)((ISdl)this).GetErrorRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyRWLock")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyRWLock(RWLockHandle rwlock) => DllImport.DestroyRWLock(rwlock); + public static Ptr GetError() => DllImport.GetError(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroySemaphore(SemaphoreHandle sem) => + sbyte* ISdl.GetErrorRaw() => ( - (delegate* unmanaged)( - _slots[94] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[284] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[94] = nativeContext.LoadFunction("SDL_DestroySemaphore", "SDL3") + : _slots[284] = nativeContext.LoadFunction("SDL_GetError", "SDL3") ) - )(sem); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySemaphore")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroySemaphore(SemaphoreHandle sem) => DllImport.DestroySemaphore(sem); + public static sbyte* GetErrorRaw() => DllImport.GetErrorRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroySurface(Surface* surface) => + byte ISdl.GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, + void** userdata + ) => ( - (delegate* unmanaged)( - _slots[95] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[285] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[95] = nativeContext.LoadFunction("SDL_DestroySurface", "SDL3") + : _slots[285] = nativeContext.LoadFunction("SDL_GetEventFilter", "SDL3") ) - )(surface); + )(filter, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroySurface(Surface* surface) => DllImport.DestroySurface(surface); + public static byte GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, + void** userdata + ) => DllImport.GetEventFilter(filter, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroySurface(Ref surface) + MaybeBool ISdl.GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] Ref filter, + Ref2D userdata + ) { - fixed (Surface* __dsl_surface = surface) + fixed (void** __dsl_userdata = userdata) + fixed (EventFilter* __dsl_filter = filter) { - ((ISdl)this).DestroySurface(__dsl_surface); + return (MaybeBool)(byte)((ISdl)this).GetEventFilter(__dsl_filter, __dsl_userdata); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroySurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroySurface(Ref surface) => DllImport.DestroySurface(surface); + public static MaybeBool GetEventFilter( + [NativeTypeName("SDL_EventFilter *")] Ref filter, + Ref2D userdata + ) => DllImport.GetEventFilter(filter, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyTexture(Texture* texture) => + float ISdl.GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float default_value + ) => ( - (delegate* unmanaged)( - _slots[96] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[286] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[96] = nativeContext.LoadFunction("SDL_DestroyTexture", "SDL3") + : _slots[286] = nativeContext.LoadFunction("SDL_GetFloatProperty", "SDL3") ) - )(texture); + )(props, name, default_value); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyTexture(Texture* texture) => DllImport.DestroyTexture(texture); + public static float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float default_value + ) => DllImport.GetFloatProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyTexture(Ref texture) + float ISdl.GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float default_value + ) { - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_name = name) { - ((ISdl)this).DestroyTexture(__dsl_texture); + return (float)((ISdl)this).GetFloatProperty(props, __dsl_name, default_value); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyTexture(Ref texture) => DllImport.DestroyTexture(texture); + public static float GetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float default_value + ) => DllImport.GetFloatProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DestroyWindow(WindowHandle window) => + DisplayMode** ISdl.GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int* count + ) => ( - (delegate* unmanaged)( - _slots[97] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[287] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[97] = nativeContext.LoadFunction("SDL_DestroyWindow", "SDL3") + : _slots[287] = nativeContext.LoadFunction( + "SDL_GetFullscreenDisplayModes", + "SDL3" + ) ) - )(window); + )(displayID, count); - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DestroyWindow(WindowHandle window) => DllImport.DestroyWindow(window); + public static DisplayMode** GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + int* count + ) => DllImport.GetFullscreenDisplayModes(displayID, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.DestroyWindowSurface(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).DestroyWindowSurfaceRaw(window); + Ptr2D ISdl.GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (DisplayMode**)((ISdl)this).GetFullscreenDisplayModes(displayID, __dsl_count); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool DestroyWindowSurface(WindowHandle window) => - DllImport.DestroyWindowSurface(window); + public static Ptr2D GetFullscreenDisplayModes( + [NativeTypeName("SDL_DisplayID")] uint displayID, + Ref count + ) => DllImport.GetFullscreenDisplayModes(displayID, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.DestroyWindowSurfaceRaw(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[98] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[98] = nativeContext.LoadFunction("SDL_DestroyWindowSurface", "SDL3") - ) - )(window); + Ptr ISdl.GetGamepadAppleSFSymbolsNameForAxis(GamepadHandle gamepad, GamepadAxis axis) => + (sbyte*)((ISdl)this).GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DestroyWindowSurface")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte DestroyWindowSurfaceRaw(WindowHandle window) => - DllImport.DestroyWindowSurfaceRaw(window); + public static Ptr GetGamepadAppleSFSymbolsNameForAxis( + GamepadHandle gamepad, + GamepadAxis axis + ) => DllImport.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.DetachThread(ThreadHandle thread) => + sbyte* ISdl.GetGamepadAppleSFSymbolsNameForAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => ( - (delegate* unmanaged)( - _slots[99] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[288] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[99] = nativeContext.LoadFunction("SDL_DetachThread", "SDL3") + : _slots[288] = nativeContext.LoadFunction( + "SDL_GetGamepadAppleSFSymbolsNameForAxis", + "SDL3" + ) ) - )(thread); + )(gamepad, axis); - [NativeFunction("SDL3", EntryPoint = "SDL_DetachThread")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void DetachThread(ThreadHandle thread) => DllImport.DetachThread(thread); + public static sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( + GamepadHandle gamepad, + GamepadAxis axis + ) => DllImport.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.DetachVirtualJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => (MaybeBool)(byte)((ISdl)this).DetachVirtualJoystickRaw(instance_id); + Ptr ISdl.GetGamepadAppleSFSymbolsNameForButton( + GamepadHandle gamepad, + GamepadButton button + ) => (sbyte*)((ISdl)this).GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool DetachVirtualJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.DetachVirtualJoystick(instance_id); + public static Ptr GetGamepadAppleSFSymbolsNameForButton( + GamepadHandle gamepad, + GamepadButton button + ) => DllImport.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.DetachVirtualJoystickRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + sbyte* ISdl.GetGamepadAppleSFSymbolsNameForButtonRaw( + GamepadHandle gamepad, + GamepadButton button + ) => ( - (delegate* unmanaged)( - _slots[100] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[289] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[100] = nativeContext.LoadFunction("SDL_DetachVirtualJoystick", "SDL3") + : _slots[289] = nativeContext.LoadFunction( + "SDL_GetGamepadAppleSFSymbolsNameForButton", + "SDL3" + ) ) - )(instance_id); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DetachVirtualJoystick")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte DetachVirtualJoystickRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.DetachVirtualJoystickRaw(instance_id); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.DisableScreenSaver() => - (MaybeBool)(byte)((ISdl)this).DisableScreenSaverRaw(); + )(gamepad, button); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool DisableScreenSaver() => DllImport.DisableScreenSaver(); + public static sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( + GamepadHandle gamepad, + GamepadButton button + ) => DllImport.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.DisableScreenSaverRaw() => + short ISdl.GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => ( - (delegate* unmanaged)( - _slots[101] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[290] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[101] = nativeContext.LoadFunction("SDL_DisableScreenSaver", "SDL3") + : _slots[290] = nativeContext.LoadFunction("SDL_GetGamepadAxis", "SDL3") ) - )(); + )(gamepad, axis); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_DisableScreenSaver")] + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte DisableScreenSaverRaw() => DllImport.DisableScreenSaverRaw(); + public static short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => + DllImport.GetGamepadAxis(gamepad, axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.DuplicateSurface(Surface* surface) => + GamepadAxis ISdl.GetGamepadAxisFromString([NativeTypeName("const char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[102] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[291] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[102] = nativeContext.LoadFunction("SDL_DuplicateSurface", "SDL3") + : _slots[291] = nativeContext.LoadFunction( + "SDL_GetGamepadAxisFromString", + "SDL3" + ) ) - )(surface); + )(str); - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* DuplicateSurface(Surface* surface) => - DllImport.DuplicateSurface(surface); + public static GamepadAxis GetGamepadAxisFromString( + [NativeTypeName("const char *")] sbyte* str + ) => DllImport.GetGamepadAxisFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.DuplicateSurface(Ref surface) + GamepadAxis ISdl.GetGamepadAxisFromString([NativeTypeName("const char *")] Ref str) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_str = str) { - return (Surface*)((ISdl)this).DuplicateSurface(__dsl_surface); + return (GamepadAxis)((ISdl)this).GetGamepadAxisFromString(__dsl_str); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_DuplicateSurface")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr DuplicateSurface(Ref surface) => - DllImport.DuplicateSurface(surface); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.EGLGetCurrentConfig() => (void*)((ISdl)this).EGLGetCurrentConfigRaw(); - - [return: NativeTypeName("SDL_EGLConfig")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr EGLGetCurrentConfig() => DllImport.EGLGetCurrentConfig(); + public static GamepadAxis GetGamepadAxisFromString( + [NativeTypeName("const char *")] Ref str + ) => DllImport.GetGamepadAxisFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.EGLGetCurrentConfigRaw() => + GamepadBinding** ISdl.GetGamepadBindings(GamepadHandle gamepad, int* count) => ( - (delegate* unmanaged)( - _slots[103] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[292] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[103] = nativeContext.LoadFunction("SDL_EGL_GetCurrentConfig", "SDL3") + : _slots[292] = nativeContext.LoadFunction("SDL_GetGamepadBindings", "SDL3") ) - )(); + )(gamepad, count); - [return: NativeTypeName("SDL_EGLConfig")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentConfig")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* EGLGetCurrentConfigRaw() => DllImport.EGLGetCurrentConfigRaw(); + public static GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => + DllImport.GetGamepadBindings(gamepad, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.EGLGetCurrentDisplay() => (void*)((ISdl)this).EGLGetCurrentDisplayRaw(); + Ptr2D ISdl.GetGamepadBindings(GamepadHandle gamepad, Ref count) + { + fixed (int* __dsl_count = count) + { + return (GamepadBinding**)((ISdl)this).GetGamepadBindings(gamepad, __dsl_count); + } + } - [return: NativeTypeName("SDL_EGLDisplay")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr EGLGetCurrentDisplay() => DllImport.EGLGetCurrentDisplay(); + public static Ptr2D GetGamepadBindings(GamepadHandle gamepad, Ref count) => + DllImport.GetGamepadBindings(gamepad, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.EGLGetCurrentDisplayRaw() => - ( - (delegate* unmanaged)( - _slots[104] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[104] = nativeContext.LoadFunction("SDL_EGL_GetCurrentDisplay", "SDL3") - ) - )(); + MaybeBool ISdl.GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => + (MaybeBool)(byte)((ISdl)this).GetGamepadButtonRaw(gamepad, button); - [return: NativeTypeName("SDL_EGLDisplay")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetCurrentDisplay")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* EGLGetCurrentDisplayRaw() => DllImport.EGLGetCurrentDisplayRaw(); + public static MaybeBool GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => + DllImport.GetGamepadButton(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + GamepadButton ISdl.GetGamepadButtonFromString([NativeTypeName("const char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[105] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[294] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[105] = nativeContext.LoadFunction("SDL_EGL_GetProcAddress", "SDL3") + : _slots[294] = nativeContext.LoadFunction( + "SDL_GetGamepadButtonFromString", + "SDL3" + ) ) - )(proc); + )(str); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer EGLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => - DllImport.EGLGetProcAddress(proc); + public static GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] sbyte* str + ) => DllImport.GetGamepadButtonFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.EGLGetProcAddress([NativeTypeName("const char *")] Ref proc) + GamepadButton ISdl.GetGamepadButtonFromString([NativeTypeName("const char *")] Ref str) { - fixed (sbyte* __dsl_proc = proc) + fixed (sbyte* __dsl_str = str) { - return (FunctionPointer)((ISdl)this).EGLGetProcAddress(__dsl_proc); + return (GamepadButton)((ISdl)this).GetGamepadButtonFromString(__dsl_str); } } - [return: NativeTypeName("SDL_FunctionPointer")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetProcAddress")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer EGLGetProcAddress( - [NativeTypeName("const char *")] Ref proc - ) => DllImport.EGLGetProcAddress(proc); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.EGLGetWindowSurface(WindowHandle window) => - (void*)((ISdl)this).EGLGetWindowSurfaceRaw(window); - - [return: NativeTypeName("SDL_EGLSurface")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr EGLGetWindowSurface(WindowHandle window) => - DllImport.EGLGetWindowSurface(window); + public static GamepadButton GetGamepadButtonFromString( + [NativeTypeName("const char *")] Ref str + ) => DllImport.GetGamepadButtonFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.EGLGetWindowSurfaceRaw(WindowHandle window) => + GamepadButtonLabel ISdl.GetGamepadButtonLabel(GamepadHandle gamepad, GamepadButton button) => ( - (delegate* unmanaged)( - _slots[106] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[295] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[106] = nativeContext.LoadFunction("SDL_EGL_GetWindowSurface", "SDL3") + : _slots[295] = nativeContext.LoadFunction("SDL_GetGamepadButtonLabel", "SDL3") ) - )(window); + )(gamepad, button); - [return: NativeTypeName("SDL_EGLSurface")] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* EGLGetWindowSurfaceRaw(WindowHandle window) => - DllImport.EGLGetWindowSurfaceRaw(window); + public static GamepadButtonLabel GetGamepadButtonLabel( + GamepadHandle gamepad, + GamepadButton button + ) => DllImport.GetGamepadButtonLabel(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - void* userdata - ) => + GamepadButtonLabel ISdl.GetGamepadButtonLabelForType(GamepadType type, GamepadButton button) => ( - (delegate* unmanaged< - EGLAttribArrayCallback, - EGLIntArrayCallback, - EGLIntArrayCallback, - void*, - void>)( - _slots[107] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[296] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[107] = nativeContext.LoadFunction( - "SDL_EGL_SetAttributeCallbacks", + : _slots[296] = nativeContext.LoadFunction( + "SDL_GetGamepadButtonLabelForType", "SDL3" ) ) - )(platformAttribCallback, surfaceAttribCallback, contextAttribCallback, userdata); - - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - void* userdata - ) => - DllImport.EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - userdata - ); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - ((ISdl)this).EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - __dsl_userdata - ); - } - } + )(type, button); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EGL_SetAttributeCallbacks")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void EGLSetAttributeCallbacks( - [NativeTypeName("SDL_EGLAttribArrayCallback")] - EGLAttribArrayCallback platformAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback surfaceAttribCallback, - [NativeTypeName("SDL_EGLIntArrayCallback")] EGLIntArrayCallback contextAttribCallback, - Ref userdata - ) => - DllImport.EGLSetAttributeCallbacks( - platformAttribCallback, - surfaceAttribCallback, - contextAttribCallback, - userdata - ); + public static GamepadButtonLabel GetGamepadButtonLabelForType( + GamepadType type, + GamepadButton button + ) => DllImport.GetGamepadButtonLabelForType(type, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.EnableScreenSaver() => - (MaybeBool)(byte)((ISdl)this).EnableScreenSaverRaw(); + byte ISdl.GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => + ( + (delegate* unmanaged)( + _slots[293] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[293] = nativeContext.LoadFunction("SDL_GetGamepadButton", "SDL3") + ) + )(gamepad, button); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool EnableScreenSaver() => DllImport.EnableScreenSaver(); + public static byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => + DllImport.GetGamepadButtonRaw(gamepad, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.EnableScreenSaverRaw() => + JoystickConnectionState ISdl.GetGamepadConnectionState(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[108] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[297] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[108] = nativeContext.LoadFunction("SDL_EnableScreenSaver", "SDL3") + : _slots[297] = nativeContext.LoadFunction( + "SDL_GetGamepadConnectionState", + "SDL3" + ) ) - )(); + )(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnableScreenSaver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte EnableScreenSaverRaw() => DllImport.EnableScreenSaverRaw(); + public static JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => + DllImport.GetGamepadConnectionState(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.EnumerateDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => + ushort ISdl.GetGamepadFirmwareVersion(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[109] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[298] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[109] = nativeContext.LoadFunction("SDL_EnumerateDirectory", "SDL3") + : _slots[298] = nativeContext.LoadFunction( + "SDL_GetGamepadFirmwareVersion", + "SDL3" + ) ) - )(path, callback, userdata); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte EnumerateDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => DllImport.EnumerateDirectory(path, callback, userdata); + )(gamepad); + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.EnumerateDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)((ISdl)this).EnumerateDirectory(__dsl_path, callback, __dsl_userdata); - } - } + public static ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => + DllImport.GetGamepadFirmwareVersion(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool EnumerateDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) => DllImport.EnumerateDirectory(path, callback, userdata); + GamepadHandle ISdl.GetGamepadFromID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[299] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[299] = nativeContext.LoadFunction("SDL_GetGamepadFromID", "SDL3") + ) + )(instance_id); + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, - void* userdata - ) => + public static GamepadHandle GetGamepadFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadFromID(instance_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + GamepadHandle ISdl.GetGamepadFromPlayerIndex(int player_index) => ( - (delegate* unmanaged)( - _slots[110] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[300] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[110] = nativeContext.LoadFunction("SDL_EnumerateProperties", "SDL3") + : _slots[300] = nativeContext.LoadFunction( + "SDL_GetGamepadFromPlayerIndex", + "SDL3" + ) ) - )(props, callback, userdata); + )(player_index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, - void* userdata - ) => DllImport.EnumerateProperties(props, callback, userdata); + public static GamepadHandle GetGamepadFromPlayerIndex(int player_index) => + DllImport.GetGamepadFromPlayerIndex(player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (MaybeBool) - (byte)((ISdl)this).EnumerateProperties(props, callback, __dsl_userdata); - } - } + Guid ISdl.GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[301] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[301] = nativeContext.LoadFunction("SDL_GetGamepadGUIDForID", "SDL3") + ) + )(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool EnumerateProperties( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("SDL_EnumeratePropertiesCallback")] EnumeratePropertiesCallback callback, - Ref userdata - ) => DllImport.EnumerateProperties(props, callback, userdata); + public static Guid GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.GetGamepadGuidForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => + uint ISdl.GetGamepadID(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[111] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[302] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[111] = nativeContext.LoadFunction( - "SDL_EnumerateStorageDirectory", - "SDL3" - ) + : _slots[302] = nativeContext.LoadFunction("SDL_GetGamepadID", "SDL3") ) - )(storage, path, callback, userdata); + )(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - void* userdata - ) => DllImport.EnumerateStorageDirectory(storage, path, callback, userdata); + public static uint GetGamepadID(GamepadHandle gamepad) => DllImport.GetGamepadID(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte) - ((ISdl)this).EnumerateStorageDirectory( - storage, - __dsl_path, - callback, - __dsl_userdata - ); - } - } + JoystickHandle ISdl.GetGamepadJoystick(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[303] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[303] = nativeContext.LoadFunction("SDL_GetGamepadJoystick", "SDL3") + ) + )(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EnumerateStorageDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool EnumerateStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("SDL_EnumerateDirectoryCallback")] EnumerateDirectoryCallback callback, - Ref userdata - ) => DllImport.EnumerateStorageDirectory(storage, path, callback, userdata); + public static JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => + DllImport.GetGamepadJoystick(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.EventEnabled([NativeTypeName("Uint32")] uint type) => - (MaybeBool)(byte)((ISdl)this).EventEnabledRaw(type); + Ptr ISdl.GetGamepadMapping(GamepadHandle gamepad) => + (sbyte*)((ISdl)this).GetGamepadMappingRaw(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool EventEnabled([NativeTypeName("Uint32")] uint type) => - DllImport.EventEnabled(type); + public static Ptr GetGamepadMapping(GamepadHandle gamepad) => + DllImport.GetGamepadMapping(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.EventEnabledRaw([NativeTypeName("Uint32")] uint type) => - ( - (delegate* unmanaged)( - _slots[112] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[112] = nativeContext.LoadFunction("SDL_EventEnabled", "SDL3") - ) - )(type); + Ptr ISdl.GetGamepadMappingForGuid(Guid guid) => + (sbyte*)((ISdl)this).GetGamepadMappingForGuidRaw(guid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_EventEnabled")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte EventEnabledRaw([NativeTypeName("Uint32")] uint type) => - DllImport.EventEnabledRaw(type); + public static Ptr GetGamepadMappingForGuid(Guid guid) => + DllImport.GetGamepadMappingForGuid(guid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FillSurfaceRect( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("Uint32")] uint color - ) => + sbyte* ISdl.GetGamepadMappingForGuidRaw(Guid guid) => ( - (delegate* unmanaged)( - _slots[113] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[305] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[113] = nativeContext.LoadFunction("SDL_FillSurfaceRect", "SDL3") + : _slots[305] = nativeContext.LoadFunction( + "SDL_GetGamepadMappingForGUID", + "SDL3" + ) ) - )(dst, rect, color); + )(guid); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FillSurfaceRect( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - [NativeTypeName("Uint32")] uint color - ) => DllImport.FillSurfaceRect(dst, rect, color); + public static sbyte* GetGamepadMappingForGuidRaw(Guid guid) => + DllImport.GetGamepadMappingForGuidRaw(guid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FillSurfaceRect( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("Uint32")] uint color - ) - { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_dst = dst) - { - return (MaybeBool) - (byte)((ISdl)this).FillSurfaceRect(__dsl_dst, __dsl_rect, color); - } - } + Ptr ISdl.GetGamepadMappingForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (sbyte*)((ISdl)this).GetGamepadMappingForIDRaw(instance_id); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FillSurfaceRect( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rect, - [NativeTypeName("Uint32")] uint color - ) => DllImport.FillSurfaceRect(dst, rect, color); + public static Ptr GetGamepadMappingForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadMappingForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FillSurfaceRects( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => + sbyte* ISdl.GetGamepadMappingForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[114] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[306] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[114] = nativeContext.LoadFunction("SDL_FillSurfaceRects", "SDL3") + : _slots[306] = nativeContext.LoadFunction("SDL_GetGamepadMappingForID", "SDL3") ) - )(dst, rects, count, color); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FillSurfaceRects( - Surface* dst, - [NativeTypeName("const SDL_Rect *")] Rect* rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => DllImport.FillSurfaceRects(dst, rects, count, color); + public static sbyte* GetGamepadMappingForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadMappingForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FillSurfaceRects( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int count, - [NativeTypeName("Uint32")] uint color - ) - { - fixed (Rect* __dsl_rects = rects) - fixed (Surface* __dsl_dst = dst) - { - return (MaybeBool) - (byte)((ISdl)this).FillSurfaceRects(__dsl_dst, __dsl_rects, count, color); - } - } + sbyte* ISdl.GetGamepadMappingRaw(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[304] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[304] = nativeContext.LoadFunction("SDL_GetGamepadMapping", "SDL3") + ) + )(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FillSurfaceRects")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FillSurfaceRects( - Ref dst, - [NativeTypeName("const SDL_Rect *")] Ref rects, - int count, - [NativeTypeName("Uint32")] uint color - ) => DllImport.FillSurfaceRects(dst, rects, count, color); + public static sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => + DllImport.GetGamepadMappingRaw(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => + sbyte** ISdl.GetGamepadMappings(int* count) => ( - (delegate* unmanaged)( - _slots[115] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[307] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[115] = nativeContext.LoadFunction("SDL_FilterEvents", "SDL3") + : _slots[307] = nativeContext.LoadFunction("SDL_GetGamepadMappings", "SDL3") ) - )(filter, userdata); + )(count); - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => DllImport.FilterEvents(filter, userdata); + public static sbyte** GetGamepadMappings(int* count) => DllImport.GetGamepadMappings(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.FilterEvents([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) + Ptr2D ISdl.GetGamepadMappings(Ref count) { - fixed (void* __dsl_userdata = userdata) + fixed (int* __dsl_count = count) { - ((ISdl)this).FilterEvents(filter, __dsl_userdata); + return (sbyte**)((ISdl)this).GetGamepadMappings(__dsl_count); } } + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FilterEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void FilterEvents( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => DllImport.FilterEvents(filter, userdata); + public static Ptr2D GetGamepadMappings(Ref count) => + DllImport.GetGamepadMappings(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FlashWindow(WindowHandle window, FlashOperation operation) => - (MaybeBool)(byte)((ISdl)this).FlashWindowRaw(window, operation); + Ptr ISdl.GetGamepadName(GamepadHandle gamepad) => + (sbyte*)((ISdl)this).GetGamepadNameRaw(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FlashWindow(WindowHandle window, FlashOperation operation) => - DllImport.FlashWindow(window, operation); + public static Ptr GetGamepadName(GamepadHandle gamepad) => + DllImport.GetGamepadName(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FlashWindowRaw(WindowHandle window, FlashOperation operation) => + Ptr ISdl.GetGamepadNameForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (sbyte*)((ISdl)this).GetGamepadNameForIDRaw(instance_id); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetGamepadNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadNameForID(instance_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetGamepadNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[116] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[309] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[116] = nativeContext.LoadFunction("SDL_FlashWindow", "SDL3") + : _slots[309] = nativeContext.LoadFunction("SDL_GetGamepadNameForID", "SDL3") ) - )(window, operation); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlashWindow")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FlashWindowRaw(WindowHandle window, FlashOperation operation) => - DllImport.FlashWindowRaw(window, operation); + public static sbyte* GetGamepadNameForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FlipSurface(Surface* surface, FlipMode flip) => + sbyte* ISdl.GetGamepadNameRaw(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[117] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[308] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[117] = nativeContext.LoadFunction("SDL_FlipSurface", "SDL3") + : _slots[308] = nativeContext.LoadFunction("SDL_GetGamepadName", "SDL3") ) - )(surface, flip); + )(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FlipSurface(Surface* surface, FlipMode flip) => - DllImport.FlipSurface(surface, flip); + public static sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => + DllImport.GetGamepadNameRaw(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FlipSurface(Ref surface, FlipMode flip) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).FlipSurface(__dsl_surface, flip); - } - } + Ptr ISdl.GetGamepadPath(GamepadHandle gamepad) => + (sbyte*)((ISdl)this).GetGamepadPathRaw(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlipSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FlipSurface(Ref surface, FlipMode flip) => - DllImport.FlipSurface(surface, flip); + public static Ptr GetGamepadPath(GamepadHandle gamepad) => + DllImport.GetGamepadPath(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FlushAudioStream(AudioStreamHandle stream) => - (MaybeBool)(byte)((ISdl)this).FlushAudioStreamRaw(stream); + Ptr ISdl.GetGamepadPathForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (sbyte*)((ISdl)this).GetGamepadPathForIDRaw(instance_id); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FlushAudioStream(AudioStreamHandle stream) => - DllImport.FlushAudioStream(stream); + public static Ptr GetGamepadPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadPathForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FlushAudioStreamRaw(AudioStreamHandle stream) => + sbyte* ISdl.GetGamepadPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[118] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[311] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[118] = nativeContext.LoadFunction("SDL_FlushAudioStream", "SDL3") + : _slots[311] = nativeContext.LoadFunction("SDL_GetGamepadPathForID", "SDL3") ) - )(stream); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushAudioStream")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FlushAudioStreamRaw(AudioStreamHandle stream) => - DllImport.FlushAudioStreamRaw(stream); + public static sbyte* GetGamepadPathForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadPathForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.FlushEvent([NativeTypeName("Uint32")] uint type) => + sbyte* ISdl.GetGamepadPathRaw(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[119] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[310] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[119] = nativeContext.LoadFunction("SDL_FlushEvent", "SDL3") + : _slots[310] = nativeContext.LoadFunction("SDL_GetGamepadPath", "SDL3") ) - )(type); + )(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvent")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void FlushEvent([NativeTypeName("Uint32")] uint type) => - DllImport.FlushEvent(type); + public static sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => + DllImport.GetGamepadPathRaw(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.FlushEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => + int ISdl.GetGamepadPlayerIndex(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[120] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[312] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[120] = nativeContext.LoadFunction("SDL_FlushEvents", "SDL3") + : _slots[312] = nativeContext.LoadFunction("SDL_GetGamepadPlayerIndex", "SDL3") ) - )(minType, maxType); + )(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_FlushEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void FlushEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => DllImport.FlushEvents(minType, maxType); + public static int GetGamepadPlayerIndex(GamepadHandle gamepad) => + DllImport.GetGamepadPlayerIndex(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FlushIO(IOStreamHandle context) => - (MaybeBool)(byte)((ISdl)this).FlushIORaw(context); + int ISdl.GetGamepadPlayerIndexForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[313] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[313] = nativeContext.LoadFunction( + "SDL_GetGamepadPlayerIndexForID", + "SDL3" + ) + ) + )(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FlushIO(IOStreamHandle context) => DllImport.FlushIO(context); + public static int GetGamepadPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadPlayerIndexForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FlushIORaw(IOStreamHandle context) => + PowerState ISdl.GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => ( - (delegate* unmanaged)( - _slots[121] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[314] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[121] = nativeContext.LoadFunction("SDL_FlushIO", "SDL3") + : _slots[314] = nativeContext.LoadFunction("SDL_GetGamepadPowerInfo", "SDL3") ) - )(context); + )(gamepad, percent); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FlushIORaw(IOStreamHandle context) => DllImport.FlushIORaw(context); + public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => + DllImport.GetGamepadPowerInfo(gamepad, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.FlushRenderer(RendererHandle renderer) => - (MaybeBool)(byte)((ISdl)this).FlushRendererRaw(renderer); + PowerState ISdl.GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) + { + fixed (int* __dsl_percent = percent) + { + return (PowerState)((ISdl)this).GetGamepadPowerInfo(gamepad, __dsl_percent); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool FlushRenderer(RendererHandle renderer) => - DllImport.FlushRenderer(renderer); + public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) => + DllImport.GetGamepadPowerInfo(gamepad, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.FlushRendererRaw(RendererHandle renderer) => + ushort ISdl.GetGamepadProduct(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[122] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[315] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[122] = nativeContext.LoadFunction("SDL_FlushRenderer", "SDL3") + : _slots[315] = nativeContext.LoadFunction("SDL_GetGamepadProduct", "SDL3") ) - )(renderer); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_FlushRenderer")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte FlushRendererRaw(RendererHandle renderer) => - DllImport.FlushRendererRaw(renderer); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadConnected(GamepadHandle gamepad) => - (MaybeBool)(byte)((ISdl)this).GamepadConnectedRaw(gamepad); + )(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadConnected(GamepadHandle gamepad) => - DllImport.GamepadConnected(gamepad); + public static ushort GetGamepadProduct(GamepadHandle gamepad) => + DllImport.GetGamepadProduct(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadConnectedRaw(GamepadHandle gamepad) => + ushort ISdl.GetGamepadProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[123] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[316] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[123] = nativeContext.LoadFunction("SDL_GamepadConnected", "SDL3") + : _slots[316] = nativeContext.LoadFunction("SDL_GetGamepadProductForID", "SDL3") ) - )(gamepad); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadConnected")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadConnectedRaw(GamepadHandle gamepad) => - DllImport.GamepadConnectedRaw(gamepad); + public static ushort GetGamepadProductForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadProductForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadEventsEnabled() => - (MaybeBool)(byte)((ISdl)this).GamepadEventsEnabledRaw(); + ushort ISdl.GetGamepadProductVersion(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[317] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[317] = nativeContext.LoadFunction( + "SDL_GetGamepadProductVersion", + "SDL3" + ) + ) + )(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadEventsEnabled() => DllImport.GamepadEventsEnabled(); + public static ushort GetGamepadProductVersion(GamepadHandle gamepad) => + DllImport.GetGamepadProductVersion(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadEventsEnabledRaw() => + ushort ISdl.GetGamepadProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => ( - (delegate* unmanaged)( - _slots[124] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[318] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[124] = nativeContext.LoadFunction("SDL_GamepadEventsEnabled", "SDL3") + : _slots[318] = nativeContext.LoadFunction( + "SDL_GetGamepadProductVersionForID", + "SDL3" + ) ) - )(); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadEventsEnabled")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadEventsEnabledRaw() => DllImport.GamepadEventsEnabledRaw(); + public static ushort GetGamepadProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadProductVersionForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => - (MaybeBool)(byte)((ISdl)this).GamepadHasAxisRaw(gamepad, axis); + uint ISdl.GetGamepadProperties(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[319] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[319] = nativeContext.LoadFunction("SDL_GetGamepadProperties", "SDL3") + ) + )(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadHasAxis(GamepadHandle gamepad, GamepadAxis axis) => - DllImport.GamepadHasAxis(gamepad, axis); + public static uint GetGamepadProperties(GamepadHandle gamepad) => + DllImport.GetGamepadProperties(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => + uint* ISdl.GetGamepads(int* count) => ( - (delegate* unmanaged)( - _slots[125] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[320] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[125] = nativeContext.LoadFunction("SDL_GamepadHasAxis", "SDL3") + : _slots[320] = nativeContext.LoadFunction("SDL_GetGamepads", "SDL3") ) - )(gamepad, axis); + )(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasAxis")] + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadHasAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => - DllImport.GamepadHasAxisRaw(gamepad, axis); + public static uint* GetGamepads(int* count) => DllImport.GetGamepads(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => - (MaybeBool)(byte)((ISdl)this).GamepadHasButtonRaw(gamepad, button); + Ptr ISdl.GetGamepads(Ref count) + { + fixed (int* __dsl_count = count) + { + return (uint*)((ISdl)this).GetGamepads(__dsl_count); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_JoystickID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadHasButton(GamepadHandle gamepad, GamepadButton button) => - DllImport.GamepadHasButton(gamepad, button); + public static Ptr GetGamepads(Ref count) => DllImport.GetGamepads(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => + byte ISdl.GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + float* data, + int num_values + ) => ( - (delegate* unmanaged)( - _slots[126] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[321] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[126] = nativeContext.LoadFunction("SDL_GamepadHasButton", "SDL3") + : _slots[321] = nativeContext.LoadFunction("SDL_GetGamepadSensorData", "SDL3") ) - )(gamepad, button); + )(gamepad, type, data, num_values); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadHasButtonRaw(GamepadHandle gamepad, GamepadButton button) => - DllImport.GamepadHasButtonRaw(gamepad, button); + public static byte GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + float* data, + int num_values + ) => DllImport.GetGamepadSensorData(gamepad, type, data, num_values); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadHasSensor(GamepadHandle gamepad, SensorType type) => - (MaybeBool)(byte)((ISdl)this).GamepadHasSensorRaw(gamepad, type); + MaybeBool ISdl.GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + Ref data, + int num_values + ) + { + fixed (float* __dsl_data = data) + { + return (MaybeBool) + (byte)((ISdl)this).GetGamepadSensorData(gamepad, type, __dsl_data, num_values); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadHasSensor(GamepadHandle gamepad, SensorType type) => - DllImport.GamepadHasSensor(gamepad, type); + public static MaybeBool GetGamepadSensorData( + GamepadHandle gamepad, + SensorType type, + Ref data, + int num_values + ) => DllImport.GetGamepadSensorData(gamepad, type, data, num_values); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => + float ISdl.GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => ( - (delegate* unmanaged)( - _slots[127] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[322] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[127] = nativeContext.LoadFunction("SDL_GamepadHasSensor", "SDL3") + : _slots[322] = nativeContext.LoadFunction( + "SDL_GetGamepadSensorDataRate", + "SDL3" + ) ) )(gamepad, type); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadHasSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadHasSensorRaw(GamepadHandle gamepad, SensorType type) => - DllImport.GamepadHasSensorRaw(gamepad, type); + public static float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => + DllImport.GetGamepadSensorDataRate(gamepad, type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => - (MaybeBool)(byte)((ISdl)this).GamepadSensorEnabledRaw(gamepad, type); + Ptr ISdl.GetGamepadSerial(GamepadHandle gamepad) => + (sbyte*)((ISdl)this).GetGamepadSerialRaw(gamepad); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GamepadSensorEnabled(GamepadHandle gamepad, SensorType type) => - DllImport.GamepadSensorEnabled(gamepad, type); + public static Ptr GetGamepadSerial(GamepadHandle gamepad) => + DllImport.GetGamepadSerial(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => + sbyte* ISdl.GetGamepadSerialRaw(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[128] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[323] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[128] = nativeContext.LoadFunction("SDL_GamepadSensorEnabled", "SDL3") + : _slots[323] = nativeContext.LoadFunction("SDL_GetGamepadSerial", "SDL3") ) - )(gamepad, type); + )(gamepad); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GamepadSensorEnabled")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GamepadSensorEnabledRaw(GamepadHandle gamepad, SensorType type) => - DllImport.GamepadSensorEnabledRaw(gamepad, type); + public static sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => + DllImport.GetGamepadSerialRaw(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => + ulong ISdl.GetGamepadSteamHandle(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[129] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[324] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[129] = nativeContext.LoadFunction("SDL_GetAppMetadataProperty", "SDL3") + : _slots[324] = nativeContext.LoadFunction("SDL_GetGamepadSteamHandle", "SDL3") ) - )(name); + )(gamepad); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetAppMetadataProperty([NativeTypeName("const char *")] sbyte* name) => - DllImport.GetAppMetadataProperty(name); + public static ulong GetGamepadSteamHandle(GamepadHandle gamepad) => + DllImport.GetGamepadSteamHandle(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAppMetadataProperty([NativeTypeName("const char *")] Ref name) - { - fixed (sbyte* __dsl_name = name) - { - return (sbyte*)((ISdl)this).GetAppMetadataProperty(__dsl_name); - } - } + Ptr ISdl.GetGamepadStringForAxis(GamepadAxis axis) => + (sbyte*)((ISdl)this).GetGamepadStringForAxisRaw(axis); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name - ) => DllImport.GetAppMetadataProperty(name); + public static Ptr GetGamepadStringForAxis(GamepadAxis axis) => + DllImport.GetGamepadStringForAxis(axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertionHandler ISdl.GetAssertionHandler(void** puserdata) => + sbyte* ISdl.GetGamepadStringForAxisRaw(GamepadAxis axis) => ( - (delegate* unmanaged)( - _slots[130] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[325] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[130] = nativeContext.LoadFunction("SDL_GetAssertionHandler", "SDL3") + : _slots[325] = nativeContext.LoadFunction( + "SDL_GetGamepadStringForAxis", + "SDL3" + ) ) - )(puserdata); + )(axis); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertionHandler GetAssertionHandler(void** puserdata) => - DllImport.GetAssertionHandler(puserdata); + public static sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => + DllImport.GetGamepadStringForAxisRaw(axis); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertionHandler ISdl.GetAssertionHandler(Ref2D puserdata) - { - fixed (void** __dsl_puserdata = puserdata) - { - return (AssertionHandler)((ISdl)this).GetAssertionHandler(__dsl_puserdata); - } - } + Ptr ISdl.GetGamepadStringForButton(GamepadButton button) => + (sbyte*)((ISdl)this).GetGamepadStringForButtonRaw(button); - [return: NativeTypeName("SDL_AssertionHandler")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertionHandler GetAssertionHandler(Ref2D puserdata) => - DllImport.GetAssertionHandler(puserdata); + public static Ptr GetGamepadStringForButton(GamepadButton button) => + DllImport.GetGamepadStringForButton(button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAssertionReport() => (AssertData*)((ISdl)this).GetAssertionReportRaw(); + sbyte* ISdl.GetGamepadStringForButtonRaw(GamepadButton button) => + ( + (delegate* unmanaged)( + _slots[326] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[326] = nativeContext.LoadFunction( + "SDL_GetGamepadStringForButton", + "SDL3" + ) + ) + )(button); - [return: NativeTypeName("const SDL_AssertData *")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => + DllImport.GetGamepadStringForButtonRaw(button); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetGamepadStringForType(GamepadType type) => + (sbyte*)((ISdl)this).GetGamepadStringForTypeRaw(type); + + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAssertionReport() => DllImport.GetAssertionReport(); + public static Ptr GetGamepadStringForType(GamepadType type) => + DllImport.GetGamepadStringForType(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertData* ISdl.GetAssertionReportRaw() => + sbyte* ISdl.GetGamepadStringForTypeRaw(GamepadType type) => ( - (delegate* unmanaged)( - _slots[131] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[327] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[131] = nativeContext.LoadFunction("SDL_GetAssertionReport", "SDL3") + : _slots[327] = nativeContext.LoadFunction( + "SDL_GetGamepadStringForType", + "SDL3" + ) ) - )(); + )(type); - [return: NativeTypeName("const SDL_AssertData *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAssertionReport")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertData* GetAssertionReportRaw() => DllImport.GetAssertionReportRaw(); + public static sbyte* GetGamepadStringForTypeRaw(GamepadType type) => + DllImport.GetGamepadStringForTypeRaw(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAtomicInt(AtomicInt* a) => + byte ISdl.GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + bool* down, + float* x, + float* y, + float* pressure + ) => ( - (delegate* unmanaged)( - _slots[132] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[328] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[132] = nativeContext.LoadFunction("SDL_GetAtomicInt", "SDL3") + : _slots[328] = nativeContext.LoadFunction( + "SDL_GetGamepadTouchpadFinger", + "SDL3" + ) ) - )(a); + )(gamepad, touchpad, finger, down, x, y, pressure); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAtomicInt(AtomicInt* a) => DllImport.GetAtomicInt(a); + public static byte GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + bool* down, + float* x, + float* y, + float* pressure + ) => DllImport.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAtomicInt(Ref a) + MaybeBool ISdl.GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + Ref down, + Ref x, + Ref y, + Ref pressure + ) { - fixed (AtomicInt* __dsl_a = a) + fixed (float* __dsl_pressure = pressure) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + fixed (bool* __dsl_down = down) { - return (int)((ISdl)this).GetAtomicInt(__dsl_a); + return (MaybeBool) + (byte) + ((ISdl)this).GetGamepadTouchpadFinger( + gamepad, + touchpad, + finger, + __dsl_down, + __dsl_x, + __dsl_y, + __dsl_pressure + ); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAtomicInt(Ref a) => DllImport.GetAtomicInt(a); + public static MaybeBool GetGamepadTouchpadFinger( + GamepadHandle gamepad, + int touchpad, + int finger, + Ref down, + Ref x, + Ref y, + Ref pressure + ) => DllImport.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetAtomicPointer(void** a) => + GamepadType ISdl.GetGamepadType(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[133] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[329] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[133] = nativeContext.LoadFunction("SDL_GetAtomicPointer", "SDL3") + : _slots[329] = nativeContext.LoadFunction("SDL_GetGamepadType", "SDL3") ) - )(a); + )(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetAtomicPointer(void** a) => DllImport.GetAtomicPointer(a); + public static GamepadType GetGamepadType(GamepadHandle gamepad) => + DllImport.GetGamepadType(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAtomicPointer(Ref2D a) - { - fixed (void** __dsl_a = a) - { - return (void*)((ISdl)this).GetAtomicPointer(__dsl_a); - } - } + GamepadType ISdl.GetGamepadTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[330] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[330] = nativeContext.LoadFunction("SDL_GetGamepadTypeForID", "SDL3") + ) + )(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAtomicPointer(Ref2D a) => DllImport.GetAtomicPointer(a); + public static GamepadType GetGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadTypeForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetAtomicU32(AtomicU32* a) => + GamepadType ISdl.GetGamepadTypeFromString([NativeTypeName("const char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[134] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[331] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[134] = nativeContext.LoadFunction("SDL_GetAtomicU32", "SDL3") + : _slots[331] = nativeContext.LoadFunction( + "SDL_GetGamepadTypeFromString", + "SDL3" + ) ) - )(a); + )(str); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetAtomicU32(AtomicU32* a) => DllImport.GetAtomicU32(a); + public static GamepadType GetGamepadTypeFromString( + [NativeTypeName("const char *")] sbyte* str + ) => DllImport.GetGamepadTypeFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetAtomicU32(Ref a) + GamepadType ISdl.GetGamepadTypeFromString([NativeTypeName("const char *")] Ref str) { - fixed (AtomicU32* __dsl_a = a) + fixed (sbyte* __dsl_str = str) { - return (uint)((ISdl)this).GetAtomicU32(__dsl_a); + return (GamepadType)((ISdl)this).GetGamepadTypeFromString(__dsl_str); } } - [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetAtomicU32(Ref a) => DllImport.GetAtomicU32(a); + public static GamepadType GetGamepadTypeFromString( + [NativeTypeName("const char *")] Ref str + ) => DllImport.GetGamepadTypeFromString(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int* ISdl.GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - int* count - ) => + ushort ISdl.GetGamepadVendor(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[135] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[332] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[135] = nativeContext.LoadFunction( - "SDL_GetAudioDeviceChannelMap", - "SDL3" - ) + : _slots[332] = nativeContext.LoadFunction("SDL_GetGamepadVendor", "SDL3") ) - )(devid, count); + )(gamepad); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int* GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - int* count - ) => DllImport.GetAudioDeviceChannelMap(devid, count); + public static ushort GetGamepadVendor(GamepadHandle gamepad) => + DllImport.GetGamepadVendor(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (int*)((ISdl)this).GetAudioDeviceChannelMap(devid, __dsl_count); - } - } + ushort ISdl.GetGamepadVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[333] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[333] = nativeContext.LoadFunction("SDL_GetGamepadVendorForID", "SDL3") + ) + )(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceChannelMap")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioDeviceChannelMap( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref count - ) => DllImport.GetAudioDeviceChannelMap(devid, count); + public static ushort GetGamepadVendorForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetGamepadVendorForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioSpec* spec, - int* sample_frames - ) => + uint ISdl.GetGlobalMouseState(float* x, float* y) => ( - (delegate* unmanaged)( - _slots[136] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[334] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[136] = nativeContext.LoadFunction("SDL_GetAudioDeviceFormat", "SDL3") + : _slots[334] = nativeContext.LoadFunction("SDL_GetGlobalMouseState", "SDL3") ) - )(devid, spec, sample_frames); + )(x, y); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - AudioSpec* spec, - int* sample_frames - ) => DllImport.GetAudioDeviceFormat(devid, spec, sample_frames); + public static uint GetGlobalMouseState(float* x, float* y) => + DllImport.GetGlobalMouseState(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref spec, - Ref sample_frames - ) + uint ISdl.GetGlobalMouseState(Ref x, Ref y) { - fixed (int* __dsl_sample_frames = sample_frames) - fixed (AudioSpec* __dsl_spec = spec) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) { - return (MaybeBool) - (byte)((ISdl)this).GetAudioDeviceFormat(devid, __dsl_spec, __dsl_sample_frames); + return (uint)((ISdl)this).GetGlobalMouseState(__dsl_x, __dsl_y); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetAudioDeviceFormat( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - Ref spec, - Ref sample_frames - ) => DllImport.GetAudioDeviceFormat(devid, spec, sample_frames); + public static uint GetGlobalMouseState(Ref x, Ref y) => + DllImport.GetGlobalMouseState(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + uint ISdl.GetGlobalProperties() => ( - (delegate* unmanaged)( - _slots[137] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[335] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[137] = nativeContext.LoadFunction("SDL_GetAudioDeviceGain", "SDL3") + : _slots[335] = nativeContext.LoadFunction("SDL_GetGlobalProperties", "SDL3") ) - )(devid); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceGain")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetAudioDeviceGain([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - DllImport.GetAudioDeviceGain(devid); + public static uint GetGlobalProperties() => DllImport.GetGlobalProperties(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - (sbyte*)((ISdl)this).GetAudioDeviceNameRaw(devid); + Ptr ISdl.GetGPUDeviceDriver(GPUDeviceHandle device) => + (sbyte*)((ISdl)this).GetGPUDeviceDriverRaw(device); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioDeviceName([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - DllImport.GetAudioDeviceName(devid); + public static Ptr GetGPUDeviceDriver(GPUDeviceHandle device) => + DllImport.GetGPUDeviceDriver(device); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => + sbyte* ISdl.GetGPUDeviceDriverRaw(GPUDeviceHandle device) => ( - (delegate* unmanaged)( - _slots[138] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[336] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[138] = nativeContext.LoadFunction("SDL_GetAudioDeviceName", "SDL3") + : _slots[336] = nativeContext.LoadFunction("SDL_GetGPUDeviceDriver", "SDL3") ) - )(devid); + )(device); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDeviceDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetAudioDeviceNameRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid) => - DllImport.GetAudioDeviceNameRaw(devid); + public static sbyte* GetGPUDeviceDriverRaw(GPUDeviceHandle device) => + DllImport.GetGPUDeviceDriverRaw(device); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioDriver(int index) => (sbyte*)((ISdl)this).GetAudioDriverRaw(index); + Ptr ISdl.GetGPUDriver(int index) => (sbyte*)((ISdl)this).GetGPUDriverRaw(index); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioDriver(int index) => DllImport.GetAudioDriver(index); + public static Ptr GetGPUDriver(int index) => DllImport.GetGPUDriver(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetAudioDriverRaw(int index) => + sbyte* ISdl.GetGPUDriverRaw(int index) => ( (delegate* unmanaged)( - _slots[139] is not null and var loadedFnPtr + _slots[337] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[139] = nativeContext.LoadFunction("SDL_GetAudioDriver", "SDL3") + : _slots[337] = nativeContext.LoadFunction("SDL_GetGPUDriver", "SDL3") ) )(index); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioDriver")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetAudioDriverRaw(int index) => DllImport.GetAudioDriverRaw(index); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioFormatName(AudioFormat format) => - (sbyte*)((ISdl)this).GetAudioFormatNameRaw(format); - - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioFormatName(AudioFormat format) => - DllImport.GetAudioFormatName(format); + public static sbyte* GetGPUDriverRaw(int index) => DllImport.GetGPUDriverRaw(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetAudioFormatNameRaw(AudioFormat format) => + uint ISdl.GetGPUShaderFormats(GPUDeviceHandle device) => ( - (delegate* unmanaged)( - _slots[140] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[338] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[140] = nativeContext.LoadFunction("SDL_GetAudioFormatName", "SDL3") + : _slots[338] = nativeContext.LoadFunction("SDL_GetGPUShaderFormats", "SDL3") ) - )(format); + )(device); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioFormatName")] + [return: NativeTypeName("SDL_GPUShaderFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUShaderFormats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetAudioFormatNameRaw(AudioFormat format) => - DllImport.GetAudioFormatNameRaw(format); + public static uint GetGPUShaderFormats(GPUDeviceHandle device) => + DllImport.GetGPUShaderFormats(device); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetAudioPlaybackDevices(int* count) => + GPUTextureFormat ISdl.GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ) => ( - (delegate* unmanaged)( - _slots[141] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[339] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[141] = nativeContext.LoadFunction( - "SDL_GetAudioPlaybackDevices", + : _slots[339] = nativeContext.LoadFunction( + "SDL_GetGPUSwapchainTextureFormat", "SDL3" ) ) - )(count); - - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetAudioPlaybackDevices(int* count) => - DllImport.GetAudioPlaybackDevices(count); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioPlaybackDevices(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)((ISdl)this).GetAudioPlaybackDevices(__dsl_count); - } - } + )(device, window); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioPlaybackDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGPUSwapchainTextureFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioPlaybackDevices(Ref count) => - DllImport.GetAudioPlaybackDevices(count); + public static GPUTextureFormat GetGPUSwapchainTextureFormat( + GPUDeviceHandle device, + WindowHandle window + ) => DllImport.GetGPUSwapchainTextureFormat(device, window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetAudioRecordingDevices(int* count) => + WindowHandle ISdl.GetGrabbedWindow() => ( - (delegate* unmanaged)( - _slots[142] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[340] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[142] = nativeContext.LoadFunction( - "SDL_GetAudioRecordingDevices", - "SDL3" - ) + : _slots[340] = nativeContext.LoadFunction("SDL_GetGrabbedWindow", "SDL3") ) - )(count); + )(); - [return: NativeTypeName("SDL_AudioDeviceID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetAudioRecordingDevices(int* count) => - DllImport.GetAudioRecordingDevices(count); + public static WindowHandle GetGrabbedWindow() => DllImport.GetGrabbedWindow(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioRecordingDevices(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)((ISdl)this).GetAudioRecordingDevices(__dsl_count); - } - } + MaybeBool ISdl.GetHapticEffectStatus(HapticHandle haptic, int effect) => + (MaybeBool)(byte)((ISdl)this).GetHapticEffectStatusRaw(haptic, effect); - [return: NativeTypeName("SDL_AudioDeviceID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioRecordingDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioRecordingDevices(Ref count) => - DllImport.GetAudioRecordingDevices(count); + public static MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => + DllImport.GetHapticEffectStatus(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAudioStreamAvailable(AudioStreamHandle stream) => + byte ISdl.GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => ( - (delegate* unmanaged)( - _slots[143] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[341] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[143] = nativeContext.LoadFunction( - "SDL_GetAudioStreamAvailable", - "SDL3" - ) + : _slots[341] = nativeContext.LoadFunction("SDL_GetHapticEffectStatus", "SDL3") ) - )(stream); + )(haptic, effect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamAvailable")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAudioStreamAvailable(AudioStreamHandle stream) => - DllImport.GetAudioStreamAvailable(stream); + public static byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => + DllImport.GetHapticEffectStatusRaw(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => + uint ISdl.GetHapticFeatures(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[144] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[342] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[144] = nativeContext.LoadFunction("SDL_GetAudioStreamData", "SDL3") + : _slots[342] = nativeContext.LoadFunction("SDL_GetHapticFeatures", "SDL3") ) - )(stream, buf, len); + )(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAudioStreamData(AudioStreamHandle stream, void* buf, int len) => - DllImport.GetAudioStreamData(stream, buf, len); + public static uint GetHapticFeatures(HapticHandle haptic) => + DllImport.GetHapticFeatures(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) - { - fixed (void* __dsl_buf = buf) - { - return (int)((ISdl)this).GetAudioStreamData(stream, __dsl_buf, len); - } - } + HapticHandle ISdl.GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[343] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[343] = nativeContext.LoadFunction("SDL_GetHapticFromID", "SDL3") + ) + )(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAudioStreamData(AudioStreamHandle stream, Ref buf, int len) => - DllImport.GetAudioStreamData(stream, buf, len); + public static HapticHandle GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => + DllImport.GetHapticFromID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetAudioStreamDevice(AudioStreamHandle stream) => + uint ISdl.GetHapticID(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[145] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[344] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[145] = nativeContext.LoadFunction("SDL_GetAudioStreamDevice", "SDL3") + : _slots[344] = nativeContext.LoadFunction("SDL_GetHapticID", "SDL3") ) - )(stream); + )(haptic); - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamDevice")] + [return: NativeTypeName("SDL_HapticID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetAudioStreamDevice(AudioStreamHandle stream) => - DllImport.GetAudioStreamDevice(stream); + public static uint GetHapticID(HapticHandle haptic) => DllImport.GetHapticID(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetAudioStreamFormat( - AudioStreamHandle stream, - AudioSpec* src_spec, - AudioSpec* dst_spec - ) => - ( - (delegate* unmanaged)( - _slots[146] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[146] = nativeContext.LoadFunction("SDL_GetAudioStreamFormat", "SDL3") - ) - )(stream, src_spec, dst_spec); + Ptr ISdl.GetHapticName(HapticHandle haptic) => + (sbyte*)((ISdl)this).GetHapticNameRaw(haptic); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetAudioStreamFormat( - AudioStreamHandle stream, - AudioSpec* src_spec, - AudioSpec* dst_spec - ) => DllImport.GetAudioStreamFormat(stream, src_spec, dst_spec); + public static Ptr GetHapticName(HapticHandle haptic) => DllImport.GetHapticName(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetAudioStreamFormat( - AudioStreamHandle stream, - Ref src_spec, - Ref dst_spec - ) - { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (MaybeBool) - (byte)((ISdl)this).GetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); - } - } + Ptr ISdl.GetHapticNameForID([NativeTypeName("SDL_HapticID")] uint instance_id) => + (sbyte*)((ISdl)this).GetHapticNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetAudioStreamFormat( - AudioStreamHandle stream, - Ref src_spec, - Ref dst_spec - ) => DllImport.GetAudioStreamFormat(stream, src_spec, dst_spec); + public static Ptr GetHapticNameForID( + [NativeTypeName("SDL_HapticID")] uint instance_id + ) => DllImport.GetHapticNameForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => + sbyte* ISdl.GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[147] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[346] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[147] = nativeContext.LoadFunction( - "SDL_GetAudioStreamFrequencyRatio", - "SDL3" - ) + : _slots[346] = nativeContext.LoadFunction("SDL_GetHapticNameForID", "SDL3") ) - )(stream); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamFrequencyRatio")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetAudioStreamFrequencyRatio(AudioStreamHandle stream) => - DllImport.GetAudioStreamFrequencyRatio(stream); + public static sbyte* GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => + DllImport.GetHapticNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetAudioStreamGain(AudioStreamHandle stream) => + sbyte* ISdl.GetHapticNameRaw(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[148] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[345] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[148] = nativeContext.LoadFunction("SDL_GetAudioStreamGain", "SDL3") + : _slots[345] = nativeContext.LoadFunction("SDL_GetHapticName", "SDL3") ) - )(stream); + )(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamGain")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetAudioStreamGain(AudioStreamHandle stream) => - DllImport.GetAudioStreamGain(stream); + public static sbyte* GetHapticNameRaw(HapticHandle haptic) => + DllImport.GetHapticNameRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int* ISdl.GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => + uint* ISdl.GetHaptics(int* count) => ( - (delegate* unmanaged)( - _slots[149] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[347] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[149] = nativeContext.LoadFunction( - "SDL_GetAudioStreamInputChannelMap", - "SDL3" - ) + : _slots[347] = nativeContext.LoadFunction("SDL_GetHaptics", "SDL3") ) - )(stream, count); + )(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [return: NativeTypeName("SDL_HapticID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int* GetAudioStreamInputChannelMap(AudioStreamHandle stream, int* count) => - DllImport.GetAudioStreamInputChannelMap(stream, count); + public static uint* GetHaptics(int* count) => DllImport.GetHaptics(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioStreamInputChannelMap(AudioStreamHandle stream, Ref count) + Ptr ISdl.GetHaptics(Ref count) { fixed (int* __dsl_count = count) { - return (int*)((ISdl)this).GetAudioStreamInputChannelMap(stream, __dsl_count); + return (uint*)((ISdl)this).GetHaptics(__dsl_count); } } + [return: NativeTypeName("SDL_HapticID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioStreamInputChannelMap( - AudioStreamHandle stream, - Ref count - ) => DllImport.GetAudioStreamInputChannelMap(stream, count); + public static Ptr GetHaptics(Ref count) => DllImport.GetHaptics(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int* ISdl.GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => + sbyte* ISdl.GetHint([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[150] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[348] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[150] = nativeContext.LoadFunction( - "SDL_GetAudioStreamOutputChannelMap", - "SDL3" - ) + : _slots[348] = nativeContext.LoadFunction("SDL_GetHint", "SDL3") ) - )(stream, count); + )(name); - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int* GetAudioStreamOutputChannelMap(AudioStreamHandle stream, int* count) => - DllImport.GetAudioStreamOutputChannelMap(stream, count); + public static sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => + DllImport.GetHint(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetAudioStreamOutputChannelMap(AudioStreamHandle stream, Ref count) + Ptr ISdl.GetHint([NativeTypeName("const char *")] Ref name) { - fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_name = name) { - return (int*)((ISdl)this).GetAudioStreamOutputChannelMap(stream, __dsl_count); + return (sbyte*)((ISdl)this).GetHint(__dsl_name); } } - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamOutputChannelMap")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - Ref count - ) => DllImport.GetAudioStreamOutputChannelMap(stream, count); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetAudioStreamProperties(AudioStreamHandle stream) => - ( - (delegate* unmanaged)( - _slots[151] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[151] = nativeContext.LoadFunction( - "SDL_GetAudioStreamProperties", - "SDL3" - ) - ) - )(stream); - - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamProperties")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetAudioStreamProperties(AudioStreamHandle stream) => - DllImport.GetAudioStreamProperties(stream); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetAudioStreamQueued(AudioStreamHandle stream) => - ( - (delegate* unmanaged)( - _slots[152] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[152] = nativeContext.LoadFunction("SDL_GetAudioStreamQueued", "SDL3") - ) - )(stream); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetAudioStreamQueued")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetAudioStreamQueued(AudioStreamHandle stream) => - DllImport.GetAudioStreamQueued(stream); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetBasePath() => (sbyte*)((ISdl)this).GetBasePathRaw(); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetBasePath() => DllImport.GetBasePath(); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetBasePathRaw() => - ( - (delegate* unmanaged)( - _slots[153] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[153] = nativeContext.LoadFunction("SDL_GetBasePath", "SDL3") - ) - )(); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBasePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetBasePathRaw() => DllImport.GetBasePathRaw(); + public static Ptr GetHint([NativeTypeName("const char *")] Ref name) => + DllImport.GetHint(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, + byte ISdl.GetHintBoolean( [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("bool")] byte default_value ) => ( - (delegate* unmanaged)( - _slots[154] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[349] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[154] = nativeContext.LoadFunction("SDL_GetBooleanProperty", "SDL3") + : _slots[349] = nativeContext.LoadFunction("SDL_GetHintBoolean", "SDL3") ) - )(props, name, default_value); + )(name, default_value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, + public static byte GetHintBoolean( [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("bool")] byte default_value - ) => DllImport.GetBooleanProperty(props, name, default_value); + ) => DllImport.GetHintBoolean(name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, + MaybeBool ISdl.GetHintBoolean( [NativeTypeName("const char *")] Ref name, [NativeTypeName("bool")] MaybeBool default_value ) @@ -53848,21030 +73629,22213 @@ MaybeBool ISdl.GetBooleanProperty( fixed (sbyte* __dsl_name = name) { return (MaybeBool) - (byte)((ISdl)this).GetBooleanProperty(props, __dsl_name, (byte)default_value); + (byte)((ISdl)this).GetHintBoolean(__dsl_name, (byte)default_value); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, + public static MaybeBool GetHintBoolean( [NativeTypeName("const char *")] Ref name, [NativeTypeName("bool")] MaybeBool default_value - ) => DllImport.GetBooleanProperty(props, name, default_value); + ) => DllImport.GetHintBoolean(name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCameraDriver(int index) => (sbyte*)((ISdl)this).GetCameraDriverRaw(index); + uint ISdl.GetIOProperties(IOStreamHandle context) => + ( + (delegate* unmanaged)( + _slots[350] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[350] = nativeContext.LoadFunction("SDL_GetIOProperties", "SDL3") + ) + )(context); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCameraDriver(int index) => DllImport.GetCameraDriver(index); + public static uint GetIOProperties(IOStreamHandle context) => + DllImport.GetIOProperties(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetCameraDriverRaw(int index) => + long ISdl.GetIOSize(IOStreamHandle context) => ( - (delegate* unmanaged)( - _slots[155] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[351] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[155] = nativeContext.LoadFunction("SDL_GetCameraDriver", "SDL3") + : _slots[351] = nativeContext.LoadFunction("SDL_GetIOSize", "SDL3") ) - )(index); + )(context); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraDriver")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetCameraDriverRaw(int index) => DllImport.GetCameraDriverRaw(index); + public static long GetIOSize(IOStreamHandle context) => DllImport.GetIOSize(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetCameraFormat(CameraHandle camera, CameraSpec* spec) => + IOStatus ISdl.GetIOStatus(IOStreamHandle context) => + ( + (delegate* unmanaged)( + _slots[352] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[352] = nativeContext.LoadFunction("SDL_GetIOStatus", "SDL3") + ) + )(context); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static IOStatus GetIOStatus(IOStreamHandle context) => DllImport.GetIOStatus(context); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + short ISdl.GetJoystickAxis(JoystickHandle joystick, int axis) => + ( + (delegate* unmanaged)( + _slots[353] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[353] = nativeContext.LoadFunction("SDL_GetJoystickAxis", "SDL3") + ) + )(joystick, axis); + + [return: NativeTypeName("Sint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static short GetJoystickAxis(JoystickHandle joystick, int axis) => + DllImport.GetJoystickAxis(joystick, axis); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] short* state + ) => ( - (delegate* unmanaged)( - _slots[156] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[354] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[156] = nativeContext.LoadFunction("SDL_GetCameraFormat", "SDL3") + : _slots[354] = nativeContext.LoadFunction( + "SDL_GetJoystickAxisInitialState", + "SDL3" + ) ) - )(camera, spec); + )(joystick, axis, state); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetCameraFormat(CameraHandle camera, CameraSpec* spec) => - DllImport.GetCameraFormat(camera, spec); + public static byte GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] short* state + ) => DllImport.GetJoystickAxisInitialState(joystick, axis, state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetCameraFormat(CameraHandle camera, Ref spec) + MaybeBool ISdl.GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] Ref state + ) { - fixed (CameraSpec* __dsl_spec = spec) + fixed (short* __dsl_state = state) { - return (MaybeBool)(byte)((ISdl)this).GetCameraFormat(camera, __dsl_spec); + return (MaybeBool) + (byte)((ISdl)this).GetJoystickAxisInitialState(joystick, axis, __dsl_state); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetCameraFormat(CameraHandle camera, Ref spec) => - DllImport.GetCameraFormat(camera, spec); + public static MaybeBool GetJoystickAxisInitialState( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16 *")] Ref state + ) => DllImport.GetJoystickAxisInitialState(joystick, axis, state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetCameraID(CameraHandle camera) => + byte ISdl.GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => ( - (delegate* unmanaged)( - _slots[157] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[355] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[157] = nativeContext.LoadFunction("SDL_GetCameraID", "SDL3") + : _slots[355] = nativeContext.LoadFunction("SDL_GetJoystickBall", "SDL3") ) - )(camera); + )(joystick, ball, dx, dy); - [return: NativeTypeName("SDL_CameraID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetCameraID(CameraHandle camera) => DllImport.GetCameraID(camera); + public static byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => + DllImport.GetJoystickBall(joystick, ball, dx, dy); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => - (sbyte*)((ISdl)this).GetCameraNameRaw(instance_id); + MaybeBool ISdl.GetJoystickBall( + JoystickHandle joystick, + int ball, + Ref dx, + Ref dy + ) + { + fixed (int* __dsl_dy = dy) + fixed (int* __dsl_dx = dx) + { + return (MaybeBool) + (byte)((ISdl)this).GetJoystickBall(joystick, ball, __dsl_dx, __dsl_dy); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCameraName([NativeTypeName("SDL_CameraID")] uint instance_id) => - DllImport.GetCameraName(instance_id); + public static MaybeBool GetJoystickBall( + JoystickHandle joystick, + int ball, + Ref dx, + Ref dy + ) => DllImport.GetJoystickBall(joystick, ball, dx, dy); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => + MaybeBool ISdl.GetJoystickButton(JoystickHandle joystick, int button) => + (MaybeBool)(byte)((ISdl)this).GetJoystickButtonRaw(joystick, button); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => + DllImport.GetJoystickButton(joystick, button); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetJoystickButtonRaw(JoystickHandle joystick, int button) => ( - (delegate* unmanaged)( - _slots[158] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[356] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[158] = nativeContext.LoadFunction("SDL_GetCameraName", "SDL3") + : _slots[356] = nativeContext.LoadFunction("SDL_GetJoystickButton", "SDL3") ) - )(instance_id); + )(joystick, button); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetCameraNameRaw([NativeTypeName("SDL_CameraID")] uint instance_id) => - DllImport.GetCameraNameRaw(instance_id); + public static byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => + DllImport.GetJoystickButtonRaw(joystick, button); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetCameraPermissionState(CameraHandle camera) => + JoystickConnectionState ISdl.GetJoystickConnectionState(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[159] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[357] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[159] = nativeContext.LoadFunction( - "SDL_GetCameraPermissionState", + : _slots[357] = nativeContext.LoadFunction( + "SDL_GetJoystickConnectionState", "SDL3" ) ) - )(camera); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPermissionState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetCameraPermissionState(CameraHandle camera) => - DllImport.GetCameraPermissionState(camera); + public static JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => + DllImport.GetJoystickConnectionState(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CameraPosition ISdl.GetCameraPosition([NativeTypeName("SDL_CameraID")] uint instance_id) => + ushort ISdl.GetJoystickFirmwareVersion(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[160] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[358] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[160] = nativeContext.LoadFunction("SDL_GetCameraPosition", "SDL3") + : _slots[358] = nativeContext.LoadFunction( + "SDL_GetJoystickFirmwareVersion", + "SDL3" + ) ) - )(instance_id); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraPosition")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CameraPosition GetCameraPosition( - [NativeTypeName("SDL_CameraID")] uint instance_id - ) => DllImport.GetCameraPosition(instance_id); + public static ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => + DllImport.GetJoystickFirmwareVersion(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetCameraProperties(CameraHandle camera) => + JoystickHandle ISdl.GetJoystickFromID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[161] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[359] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[161] = nativeContext.LoadFunction("SDL_GetCameraProperties", "SDL3") + : _slots[359] = nativeContext.LoadFunction("SDL_GetJoystickFromID", "SDL3") ) - )(camera); + )(instance_id); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetCameraProperties(CameraHandle camera) => - DllImport.GetCameraProperties(camera); + public static JoystickHandle GetJoystickFromID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickFromID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetCameras(int* count) => + JoystickHandle ISdl.GetJoystickFromPlayerIndex(int player_index) => ( - (delegate* unmanaged)( - _slots[162] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[360] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[162] = nativeContext.LoadFunction("SDL_GetCameras", "SDL3") + : _slots[360] = nativeContext.LoadFunction( + "SDL_GetJoystickFromPlayerIndex", + "SDL3" + ) ) - )(count); - - [return: NativeTypeName("SDL_CameraID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetCameras(int* count) => DllImport.GetCameras(count); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCameras(Ref count) - { - fixed (int* __dsl_count = count) - { - return (uint*)((ISdl)this).GetCameras(__dsl_count); - } - } + )(player_index); - [return: NativeTypeName("SDL_CameraID *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameras")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCameras(Ref count) => DllImport.GetCameras(count); + public static JoystickHandle GetJoystickFromPlayerIndex(int player_index) => + DllImport.GetJoystickFromPlayerIndex(player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CameraSpec** ISdl.GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - int* count - ) => + Guid ISdl.GetJoystickGuid(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[163] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[361] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[163] = nativeContext.LoadFunction( - "SDL_GetCameraSupportedFormats", - "SDL3" - ) + : _slots[361] = nativeContext.LoadFunction("SDL_GetJoystickGUID", "SDL3") ) - )(devid, count); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CameraSpec** GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - int* count - ) => DllImport.GetCameraSupportedFormats(devid, count); + public static Guid GetJoystickGuid(JoystickHandle joystick) => + DllImport.GetJoystickGuid(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (CameraSpec**)((ISdl)this).GetCameraSupportedFormats(devid, __dsl_count); - } - } + Guid ISdl.GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + ( + (delegate* unmanaged)( + _slots[362] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[362] = nativeContext.LoadFunction("SDL_GetJoystickGUIDForID", "SDL3") + ) + )(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCameraSupportedFormats")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetCameraSupportedFormats( - [NativeTypeName("SDL_CameraID")] uint devid, - Ref count - ) => DllImport.GetCameraSupportedFormats(devid, count); + public static Guid GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.GetJoystickGuidForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetClipboardData( - [NativeTypeName("const char *")] sbyte* mime_type, - [NativeTypeName("size_t *")] nuint* size + void ISdl.GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] ushort* vendor, + [NativeTypeName("Uint16 *")] ushort* product, + [NativeTypeName("Uint16 *")] ushort* version, + [NativeTypeName("Uint16 *")] ushort* crc16 ) => ( - (delegate* unmanaged)( - _slots[164] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[363] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[164] = nativeContext.LoadFunction("SDL_GetClipboardData", "SDL3") + : _slots[363] = nativeContext.LoadFunction("SDL_GetJoystickGUIDInfo", "SDL3") ) - )(mime_type, size); + )(guid, vendor, product, version, crc16); - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetClipboardData( - [NativeTypeName("const char *")] sbyte* mime_type, - [NativeTypeName("size_t *")] nuint* size - ) => DllImport.GetClipboardData(mime_type, size); + public static void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] ushort* vendor, + [NativeTypeName("Uint16 *")] ushort* product, + [NativeTypeName("Uint16 *")] ushort* version, + [NativeTypeName("Uint16 *")] ushort* crc16 + ) => DllImport.GetJoystickGuidInfo(guid, vendor, product, version, crc16); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetClipboardData( - [NativeTypeName("const char *")] Ref mime_type, - [NativeTypeName("size_t *")] Ref size + void ISdl.GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] Ref vendor, + [NativeTypeName("Uint16 *")] Ref product, + [NativeTypeName("Uint16 *")] Ref version, + [NativeTypeName("Uint16 *")] Ref crc16 ) { - fixed (nuint* __dsl_size = size) - fixed (sbyte* __dsl_mime_type = mime_type) + fixed (ushort* __dsl_crc16 = crc16) + fixed (ushort* __dsl_version = version) + fixed (ushort* __dsl_product = product) + fixed (ushort* __dsl_vendor = vendor) { - return (void*)((ISdl)this).GetClipboardData(__dsl_mime_type, __dsl_size); + ((ISdl)this).GetJoystickGuidInfo( + guid, + __dsl_vendor, + __dsl_product, + __dsl_version, + __dsl_crc16 + ); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetClipboardData( - [NativeTypeName("const char *")] Ref mime_type, - [NativeTypeName("size_t *")] Ref size - ) => DllImport.GetClipboardData(mime_type, size); + public static void GetJoystickGuidInfo( + Guid guid, + [NativeTypeName("Uint16 *")] Ref vendor, + [NativeTypeName("Uint16 *")] Ref product, + [NativeTypeName("Uint16 *")] Ref version, + [NativeTypeName("Uint16 *")] Ref crc16 + ) => DllImport.GetJoystickGuidInfo(guid, vendor, product, version, crc16); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte** ISdl.GetClipboardMimeTypes([NativeTypeName("size_t *")] nuint* num_mime_types) => + byte ISdl.GetJoystickHat(JoystickHandle joystick, int hat) => ( - (delegate* unmanaged)( - _slots[165] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[364] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[165] = nativeContext.LoadFunction("SDL_GetClipboardMimeTypes", "SDL3") + : _slots[364] = nativeContext.LoadFunction("SDL_GetJoystickHat", "SDL3") ) - )(num_mime_types); - - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte** GetClipboardMimeTypes( - [NativeTypeName("size_t *")] nuint* num_mime_types - ) => DllImport.GetClipboardMimeTypes(num_mime_types); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetClipboardMimeTypes([NativeTypeName("size_t *")] Ref num_mime_types) - { - fixed (nuint* __dsl_num_mime_types = num_mime_types) - { - return (sbyte**)((ISdl)this).GetClipboardMimeTypes(__dsl_num_mime_types); - } - } - - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardMimeTypes")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetClipboardMimeTypes( - [NativeTypeName("size_t *")] Ref num_mime_types - ) => DllImport.GetClipboardMimeTypes(num_mime_types); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetClipboardText() => (sbyte*)((ISdl)this).GetClipboardTextRaw(); + )(joystick, hat); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [return: NativeTypeName("Uint8")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetClipboardText() => DllImport.GetClipboardText(); + public static byte GetJoystickHat(JoystickHandle joystick, int hat) => + DllImport.GetJoystickHat(joystick, hat); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetClipboardTextRaw() => + uint ISdl.GetJoystickID(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[166] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[365] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[166] = nativeContext.LoadFunction("SDL_GetClipboardText", "SDL3") + : _slots[365] = nativeContext.LoadFunction("SDL_GetJoystickID", "SDL3") ) - )(); + )(joystick); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClipboardText")] + [return: NativeTypeName("SDL_JoystickID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetClipboardTextRaw() => DllImport.GetClipboardTextRaw(); + public static uint GetJoystickID(JoystickHandle joystick) => DllImport.GetJoystickID(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] byte include_high_density_modes, - DisplayMode* mode - ) => - ( - (delegate* unmanaged)( - _slots[167] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[167] = nativeContext.LoadFunction( - "SDL_GetClosestFullscreenDisplayMode", - "SDL3" - ) - ) - )(displayID, w, h, refresh_rate, include_high_density_modes, mode); + Ptr ISdl.GetJoystickName(JoystickHandle joystick) => + (sbyte*)((ISdl)this).GetJoystickNameRaw(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] byte include_high_density_modes, - DisplayMode* mode - ) => - DllImport.GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - include_high_density_modes, - mode - ); + public static Ptr GetJoystickName(JoystickHandle joystick) => + DllImport.GetJoystickName(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] MaybeBool include_high_density_modes, - Ref mode - ) - { - fixed (DisplayMode* __dsl_mode = mode) - { - return (MaybeBool) - (byte) - ((ISdl)this).GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - (byte)include_high_density_modes, - __dsl_mode - ); - } - } + Ptr ISdl.GetJoystickNameForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (sbyte*)((ISdl)this).GetJoystickNameForIDRaw(instance_id); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetClosestFullscreenDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetClosestFullscreenDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int w, - int h, - float refresh_rate, - [NativeTypeName("bool")] MaybeBool include_high_density_modes, - Ref mode - ) => - DllImport.GetClosestFullscreenDisplayMode( - displayID, - w, - h, - refresh_rate, - include_high_density_modes, - mode - ); + public static Ptr GetJoystickNameForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickNameForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetCPUCacheLineSize() => + sbyte* ISdl.GetJoystickNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[168] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[367] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[168] = nativeContext.LoadFunction("SDL_GetCPUCacheLineSize", "SDL3") + : _slots[367] = nativeContext.LoadFunction("SDL_GetJoystickNameForID", "SDL3") ) - )(); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCPUCacheLineSize")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetCPUCacheLineSize() => DllImport.GetCPUCacheLineSize(); + public static sbyte* GetJoystickNameForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCurrentAudioDriver() => (sbyte*)((ISdl)this).GetCurrentAudioDriverRaw(); + sbyte* ISdl.GetJoystickNameRaw(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[366] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[366] = nativeContext.LoadFunction("SDL_GetJoystickName", "SDL3") + ) + )(joystick); [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCurrentAudioDriver() => DllImport.GetCurrentAudioDriver(); + public static sbyte* GetJoystickNameRaw(JoystickHandle joystick) => + DllImport.GetJoystickNameRaw(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetCurrentAudioDriverRaw() => - ( - (delegate* unmanaged)( - _slots[169] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[169] = nativeContext.LoadFunction("SDL_GetCurrentAudioDriver", "SDL3") - ) - )(); + Ptr ISdl.GetJoystickPath(JoystickHandle joystick) => + (sbyte*)((ISdl)this).GetJoystickPathRaw(joystick); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentAudioDriver")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetCurrentAudioDriverRaw() => DllImport.GetCurrentAudioDriverRaw(); + public static Ptr GetJoystickPath(JoystickHandle joystick) => + DllImport.GetJoystickPath(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCurrentCameraDriver() => (sbyte*)((ISdl)this).GetCurrentCameraDriverRaw(); + Ptr ISdl.GetJoystickPathForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (sbyte*)((ISdl)this).GetJoystickPathForIDRaw(instance_id); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCurrentCameraDriver() => DllImport.GetCurrentCameraDriver(); + public static Ptr GetJoystickPathForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickPathForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetCurrentCameraDriverRaw() => + sbyte* ISdl.GetJoystickPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[170] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[369] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[170] = nativeContext.LoadFunction("SDL_GetCurrentCameraDriver", "SDL3") + : _slots[369] = nativeContext.LoadFunction("SDL_GetJoystickPathForID", "SDL3") ) - )(); + )(instance_id); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentCameraDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetCurrentCameraDriverRaw() => DllImport.GetCurrentCameraDriverRaw(); + public static sbyte* GetJoystickPathForIDRaw( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickPathForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCurrentDisplayMode([NativeTypeName("SDL_DisplayID")] uint displayID) => - (DisplayMode*)((ISdl)this).GetCurrentDisplayModeRaw(displayID); + sbyte* ISdl.GetJoystickPathRaw(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[368] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[368] = nativeContext.LoadFunction("SDL_GetJoystickPath", "SDL3") + ) + )(joystick); - [return: NativeTypeName("const SDL_DisplayMode *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCurrentDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetCurrentDisplayMode(displayID); + public static sbyte* GetJoystickPathRaw(JoystickHandle joystick) => + DllImport.GetJoystickPathRaw(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayMode* ISdl.GetCurrentDisplayModeRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => + int ISdl.GetJoystickPlayerIndex(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[171] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[370] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[171] = nativeContext.LoadFunction("SDL_GetCurrentDisplayMode", "SDL3") + : _slots[370] = nativeContext.LoadFunction("SDL_GetJoystickPlayerIndex", "SDL3") ) - )(displayID); + )(joystick); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayMode* GetCurrentDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetCurrentDisplayModeRaw(displayID); + public static int GetJoystickPlayerIndex(JoystickHandle joystick) => + DllImport.GetJoystickPlayerIndex(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayOrientation ISdl.GetCurrentDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => + int ISdl.GetJoystickPlayerIndexForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[172] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[371] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[172] = nativeContext.LoadFunction( - "SDL_GetCurrentDisplayOrientation", + : _slots[371] = nativeContext.LoadFunction( + "SDL_GetJoystickPlayerIndexForID", "SDL3" ) ) - )(displayID); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentDisplayOrientation")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayOrientation GetCurrentDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetCurrentDisplayOrientation(displayID); + public static int GetJoystickPlayerIndexForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickPlayerIndexForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => + PowerState ISdl.GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => ( - (delegate* unmanaged)( - _slots[173] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[372] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[173] = nativeContext.LoadFunction( - "SDL_GetCurrentRenderOutputSize", - "SDL3" - ) + : _slots[372] = nativeContext.LoadFunction("SDL_GetJoystickPowerInfo", "SDL3") ) - )(renderer, w, h); + )(joystick, percent); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetCurrentRenderOutputSize(RendererHandle renderer, int* w, int* h) => - DllImport.GetCurrentRenderOutputSize(renderer, w, h); + public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => + DllImport.GetJoystickPowerInfo(joystick, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetCurrentRenderOutputSize(RendererHandle renderer, Ref w, Ref h) + PowerState ISdl.GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (int* __dsl_percent = percent) { - return (MaybeBool) - (byte)((ISdl)this).GetCurrentRenderOutputSize(renderer, __dsl_w, __dsl_h); + return (PowerState)((ISdl)this).GetJoystickPowerInfo(joystick, __dsl_percent); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetCurrentRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h - ) => DllImport.GetCurrentRenderOutputSize(renderer, w, h); + public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) => + DllImport.GetJoystickPowerInfo(joystick, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetCurrentThreadID() => + ushort ISdl.GetJoystickProduct(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[174] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[373] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[174] = nativeContext.LoadFunction("SDL_GetCurrentThreadID", "SDL3") + : _slots[373] = nativeContext.LoadFunction("SDL_GetJoystickProduct", "SDL3") ) - )(); + )(joystick); - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentThreadID")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetCurrentThreadID() => DllImport.GetCurrentThreadID(); + public static ushort GetJoystickProduct(JoystickHandle joystick) => + DllImport.GetJoystickProduct(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => + ushort ISdl.GetJoystickProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[175] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[374] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[175] = nativeContext.LoadFunction("SDL_GetCurrentTime", "SDL3") + : _slots[374] = nativeContext.LoadFunction( + "SDL_GetJoystickProductForID", + "SDL3" + ) ) - )(ticks); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetCurrentTime([NativeTypeName("SDL_Time *")] long* ticks) => - DllImport.GetCurrentTime(ticks); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) - { - fixed (long* __dsl_ticks = ticks) - { - return (MaybeBool)(byte)((ISdl)this).GetCurrentTime(__dsl_ticks); - } - } + )(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentTime")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetCurrentTime([NativeTypeName("SDL_Time *")] Ref ticks) => - DllImport.GetCurrentTime(ticks); + public static ushort GetJoystickProductForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickProductForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetCurrentVideoDriver() => (sbyte*)((ISdl)this).GetCurrentVideoDriverRaw(); + ushort ISdl.GetJoystickProductVersion(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[375] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[375] = nativeContext.LoadFunction( + "SDL_GetJoystickProductVersion", + "SDL3" + ) + ) + )(joystick); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetCurrentVideoDriver() => DllImport.GetCurrentVideoDriver(); + public static ushort GetJoystickProductVersion(JoystickHandle joystick) => + DllImport.GetJoystickProductVersion(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetCurrentVideoDriverRaw() => + ushort ISdl.GetJoystickProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => ( - (delegate* unmanaged)( - _slots[176] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[376] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[176] = nativeContext.LoadFunction("SDL_GetCurrentVideoDriver", "SDL3") + : _slots[376] = nativeContext.LoadFunction( + "SDL_GetJoystickProductVersionForID", + "SDL3" + ) ) - )(); + )(instance_id); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetCurrentVideoDriver")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetCurrentVideoDriverRaw() => DllImport.GetCurrentVideoDriverRaw(); + public static ushort GetJoystickProductVersionForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickProductVersionForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.GetCursor() => + uint ISdl.GetJoystickProperties(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[177] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[377] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[177] = nativeContext.LoadFunction("SDL_GetCursor", "SDL3") + : _slots[377] = nativeContext.LoadFunction("SDL_GetJoystickProperties", "SDL3") ) - )(); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetCursor")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle GetCursor() => DllImport.GetCursor(); + public static uint GetJoystickProperties(JoystickHandle joystick) => + DllImport.GetJoystickProperties(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetDateTimeLocalePreferences(DateFormat* dateFormat, TimeFormat* timeFormat) => + uint* ISdl.GetJoysticks(int* count) => ( - (delegate* unmanaged)( - _slots[178] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[378] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[178] = nativeContext.LoadFunction( - "SDL_GetDateTimeLocalePreferences", - "SDL3" - ) + : _slots[378] = nativeContext.LoadFunction("SDL_GetJoysticks", "SDL3") ) - )(dateFormat, timeFormat); + )(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [return: NativeTypeName("SDL_JoystickID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetDateTimeLocalePreferences( - DateFormat* dateFormat, - TimeFormat* timeFormat - ) => DllImport.GetDateTimeLocalePreferences(dateFormat, timeFormat); + public static uint* GetJoysticks(int* count) => DllImport.GetJoysticks(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetDateTimeLocalePreferences( - Ref dateFormat, - Ref timeFormat - ) + Ptr ISdl.GetJoysticks(Ref count) { - fixed (TimeFormat* __dsl_timeFormat = timeFormat) - fixed (DateFormat* __dsl_dateFormat = dateFormat) + fixed (int* __dsl_count = count) { - return (MaybeBool) - (byte)((ISdl)this).GetDateTimeLocalePreferences(__dsl_dateFormat, __dsl_timeFormat); + return (uint*)((ISdl)this).GetJoysticks(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_JoystickID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDateTimeLocalePreferences")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetDateTimeLocalePreferences( - Ref dateFormat, - Ref timeFormat - ) => DllImport.GetDateTimeLocalePreferences(dateFormat, timeFormat); + public static Ptr GetJoysticks(Ref count) => DllImport.GetJoysticks(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetDayOfWeek(int year, int month, int day) => + Ptr ISdl.GetJoystickSerial(JoystickHandle joystick) => + (sbyte*)((ISdl)this).GetJoystickSerialRaw(joystick); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetJoystickSerial(JoystickHandle joystick) => + DllImport.GetJoystickSerial(joystick); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetJoystickSerialRaw(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[179] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[379] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[179] = nativeContext.LoadFunction("SDL_GetDayOfWeek", "SDL3") + : _slots[379] = nativeContext.LoadFunction("SDL_GetJoystickSerial", "SDL3") ) - )(year, month, day); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfWeek")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetDayOfWeek(int year, int month, int day) => - DllImport.GetDayOfWeek(year, month, day); + public static sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => + DllImport.GetJoystickSerialRaw(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetDayOfYear(int year, int month, int day) => + JoystickType ISdl.GetJoystickType(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[180] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[380] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[180] = nativeContext.LoadFunction("SDL_GetDayOfYear", "SDL3") + : _slots[380] = nativeContext.LoadFunction("SDL_GetJoystickType", "SDL3") ) - )(year, month, day); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDayOfYear")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetDayOfYear(int year, int month, int day) => - DllImport.GetDayOfYear(year, month, day); + public static JoystickType GetJoystickType(JoystickHandle joystick) => + DllImport.GetJoystickType(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetDaysInMonth(int year, int month) => + JoystickType ISdl.GetJoystickTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[181] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[381] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[181] = nativeContext.LoadFunction("SDL_GetDaysInMonth", "SDL3") + : _slots[381] = nativeContext.LoadFunction("SDL_GetJoystickTypeForID", "SDL3") ) - )(year, month); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDaysInMonth")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetDaysInMonth(int year, int month) => DllImport.GetDaysInMonth(year, month); + public static JoystickType GetJoystickTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickTypeForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertionHandler ISdl.GetDefaultAssertionHandler() => + ushort ISdl.GetJoystickVendor(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[182] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[382] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[182] = nativeContext.LoadFunction( - "SDL_GetDefaultAssertionHandler", - "SDL3" - ) + : _slots[382] = nativeContext.LoadFunction("SDL_GetJoystickVendor", "SDL3") ) - )(); + )(joystick); - [return: NativeTypeName("SDL_AssertionHandler")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultAssertionHandler")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertionHandler GetDefaultAssertionHandler() => - DllImport.GetDefaultAssertionHandler(); + public static ushort GetJoystickVendor(JoystickHandle joystick) => + DllImport.GetJoystickVendor(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CursorHandle ISdl.GetDefaultCursor() => + ushort ISdl.GetJoystickVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[183] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[383] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[183] = nativeContext.LoadFunction("SDL_GetDefaultCursor", "SDL3") + : _slots[383] = nativeContext.LoadFunction("SDL_GetJoystickVendorForID", "SDL3") ) - )(); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultCursor")] + [return: NativeTypeName("Uint16")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CursorHandle GetDefaultCursor() => DllImport.GetDefaultCursor(); + public static ushort GetJoystickVendorForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetJoystickVendorForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - LogOutputFunction ISdl.GetDefaultLogOutputFunction() => + WindowHandle ISdl.GetKeyboardFocus() => ( - (delegate* unmanaged)( - _slots[184] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[384] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[184] = nativeContext.LoadFunction( - "SDL_GetDefaultLogOutputFunction", - "SDL3" - ) + : _slots[384] = nativeContext.LoadFunction("SDL_GetKeyboardFocus", "SDL3") ) )(); - [return: NativeTypeName("SDL_LogOutputFunction")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDefaultLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static LogOutputFunction GetDefaultLogOutputFunction() => - DllImport.GetDefaultLogOutputFunction(); + public static WindowHandle GetKeyboardFocus() => DllImport.GetKeyboardFocus(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetDesktopDisplayMode([NativeTypeName("SDL_DisplayID")] uint displayID) => - (DisplayMode*)((ISdl)this).GetDesktopDisplayModeRaw(displayID); + Ptr ISdl.GetKeyboardNameForID([NativeTypeName("SDL_KeyboardID")] uint instance_id) => + (sbyte*)((ISdl)this).GetKeyboardNameForIDRaw(instance_id); - [return: NativeTypeName("const SDL_DisplayMode *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetDesktopDisplayMode( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetDesktopDisplayMode(displayID); + public static Ptr GetKeyboardNameForID( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => DllImport.GetKeyboardNameForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayMode* ISdl.GetDesktopDisplayModeRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => + sbyte* ISdl.GetKeyboardNameForIDRaw([NativeTypeName("SDL_KeyboardID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[185] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[385] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[185] = nativeContext.LoadFunction("SDL_GetDesktopDisplayMode", "SDL3") + : _slots[385] = nativeContext.LoadFunction("SDL_GetKeyboardNameForID", "SDL3") ) - )(displayID); + )(instance_id); - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDesktopDisplayMode")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayMode* GetDesktopDisplayModeRaw( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetDesktopDisplayModeRaw(displayID); + public static sbyte* GetKeyboardNameForIDRaw( + [NativeTypeName("SDL_KeyboardID")] uint instance_id + ) => DllImport.GetKeyboardNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetDisplayBounds([NativeTypeName("SDL_DisplayID")] uint displayID, Rect* rect) => + uint* ISdl.GetKeyboards(int* count) => ( - (delegate* unmanaged)( - _slots[186] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[386] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[186] = nativeContext.LoadFunction("SDL_GetDisplayBounds", "SDL3") + : _slots[386] = nativeContext.LoadFunction("SDL_GetKeyboards", "SDL3") ) - )(displayID, rect); + )(count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] + [return: NativeTypeName("SDL_KeyboardID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => DllImport.GetDisplayBounds(displayID, rect); + public static uint* GetKeyboards(int* count) => DllImport.GetKeyboards(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) + Ptr ISdl.GetKeyboards(Ref count) { - fixed (Rect* __dsl_rect = rect) + fixed (int* __dsl_count = count) { - return (MaybeBool)(byte)((ISdl)this).GetDisplayBounds(displayID, __dsl_rect); + return (uint*)((ISdl)this).GetKeyboards(__dsl_count); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_KeyboardID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayBounds")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetDisplayBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) => DllImport.GetDisplayBounds(displayID, rect); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => - ( - (delegate* unmanaged)( - _slots[187] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[187] = nativeContext.LoadFunction("SDL_GetDisplayContentScale", "SDL3") - ) - )(displayID); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayContentScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetDisplayContentScale([NativeTypeName("SDL_DisplayID")] uint displayID) => - DllImport.GetDisplayContentScale(displayID); + public static Ptr GetKeyboards(Ref count) => DllImport.GetKeyboards(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => + bool* ISdl.GetKeyboardState(int* numkeys) => ( - (delegate* unmanaged)( - _slots[188] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[387] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[188] = nativeContext.LoadFunction("SDL_GetDisplayForPoint", "SDL3") + : _slots[387] = nativeContext.LoadFunction("SDL_GetKeyboardState", "SDL3") ) - )(point); + )(numkeys); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [return: NativeTypeName("const bool *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Point* point) => - DllImport.GetDisplayForPoint(point); + public static bool* GetKeyboardState(int* numkeys) => DllImport.GetKeyboardState(numkeys); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) + Ptr ISdl.GetKeyboardState(Ref numkeys) { - fixed (Point* __dsl_point = point) + fixed (int* __dsl_numkeys = numkeys) { - return (uint)((ISdl)this).GetDisplayForPoint(__dsl_point); + return (bool*)((ISdl)this).GetKeyboardState(__dsl_numkeys); } } - [return: NativeTypeName("SDL_DisplayID")] + [return: NativeTypeName("const bool *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForPoint")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayForPoint([NativeTypeName("const SDL_Point *")] Ref point) => - DllImport.GetDisplayForPoint(point); + public static Ptr GetKeyboardState(Ref numkeys) => + DllImport.GetKeyboardState(numkeys); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => + uint ISdl.GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[189] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[388] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[189] = nativeContext.LoadFunction("SDL_GetDisplayForRect", "SDL3") + : _slots[388] = nativeContext.LoadFunction("SDL_GetKeyFromName", "SDL3") ) - )(rect); + )(name); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Rect* rect) => - DllImport.GetDisplayForRect(rect); + public static uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => + DllImport.GetKeyFromName(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) + uint ISdl.GetKeyFromName([NativeTypeName("const char *")] Ref name) { - fixed (Rect* __dsl_rect = rect) + fixed (sbyte* __dsl_name = name) { - return (uint)((ISdl)this).GetDisplayForRect(__dsl_rect); + return (uint)((ISdl)this).GetKeyFromName(__dsl_name); } } - [return: NativeTypeName("SDL_DisplayID")] + [return: NativeTypeName("SDL_Keycode")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayForRect([NativeTypeName("const SDL_Rect *")] Ref rect) => - DllImport.GetDisplayForRect(rect); + public static uint GetKeyFromName([NativeTypeName("const char *")] Ref name) => + DllImport.GetKeyFromName(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayForWindow(WindowHandle window) => + uint ISdl.GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] byte key_event + ) => ( - (delegate* unmanaged)( - _slots[190] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[389] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[190] = nativeContext.LoadFunction("SDL_GetDisplayForWindow", "SDL3") + : _slots[389] = nativeContext.LoadFunction("SDL_GetKeyFromScancode", "SDL3") ) - )(window); + )(scancode, modstate, key_event); - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayForWindow")] + [return: NativeTypeName("SDL_Keycode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayForWindow(WindowHandle window) => - DllImport.GetDisplayForWindow(window); + public static uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] byte key_event + ) => DllImport.GetKeyFromScancode(scancode, modstate, key_event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => - (sbyte*)((ISdl)this).GetDisplayNameRaw(displayID); + uint ISdl.GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] MaybeBool key_event + ) => (uint)((ISdl)this).GetKeyFromScancode(scancode, modstate, (byte)key_event); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("SDL_Keycode")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetDisplayName([NativeTypeName("SDL_DisplayID")] uint displayID) => - DllImport.GetDisplayName(displayID); + public static uint GetKeyFromScancode( + Scancode scancode, + [NativeTypeName("SDL_Keymod")] ushort modstate, + [NativeTypeName("bool")] MaybeBool key_event + ) => DllImport.GetKeyFromScancode(scancode, modstate, key_event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => - ( - (delegate* unmanaged)( - _slots[191] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[191] = nativeContext.LoadFunction("SDL_GetDisplayName", "SDL3") - ) - )(displayID); + Ptr ISdl.GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => + (sbyte*)((ISdl)this).GetKeyNameRaw(key); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayName")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetDisplayNameRaw([NativeTypeName("SDL_DisplayID")] uint displayID) => - DllImport.GetDisplayNameRaw(displayID); + public static Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => + DllImport.GetKeyName(key); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => + sbyte* ISdl.GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => ( - (delegate* unmanaged)( - _slots[192] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[390] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[192] = nativeContext.LoadFunction("SDL_GetDisplayProperties", "SDL3") + : _slots[390] = nativeContext.LoadFunction("SDL_GetKeyName", "SDL3") ) - )(displayID); + )(key); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayProperties")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetDisplayProperties([NativeTypeName("SDL_DisplayID")] uint displayID) => - DllImport.GetDisplayProperties(displayID); + public static sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => + DllImport.GetKeyNameRaw(key); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetDisplays(int* count) => + void ISdl.GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, + void** userdata + ) => ( - (delegate* unmanaged)( - _slots[193] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[391] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[193] = nativeContext.LoadFunction("SDL_GetDisplays", "SDL3") + : _slots[391] = nativeContext.LoadFunction("SDL_GetLogOutputFunction", "SDL3") ) - )(count); + )(callback, userdata); - [return: NativeTypeName("SDL_DisplayID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetDisplays(int* count) => DllImport.GetDisplays(count); + public static void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, + void** userdata + ) => DllImport.GetLogOutputFunction(callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetDisplays(Ref count) + void ISdl.GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, + Ref2D userdata + ) { - fixed (int* __dsl_count = count) + fixed (void** __dsl_userdata = userdata) + fixed (LogOutputFunction* __dsl_callback = callback) { - return (uint*)((ISdl)this).GetDisplays(__dsl_count); + ((ISdl)this).GetLogOutputFunction(__dsl_callback, __dsl_userdata); } } - [return: NativeTypeName("SDL_DisplayID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplays")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetDisplays(Ref count) => DllImport.GetDisplays(count); + public static void GetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, + Ref2D userdata + ) => DllImport.GetLogOutputFunction(callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect + LogPriority ISdl.GetLogPriority(int category) => + ( + (delegate* unmanaged)( + _slots[392] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[392] = nativeContext.LoadFunction("SDL_GetLogPriority", "SDL3") + ) + )(category); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static LogPriority GetLogPriority(int category) => DllImport.GetLogPriority(category); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetMasksForPixelFormat( + PixelFormat format, + int* bpp, + [NativeTypeName("Uint32 *")] uint* Rmask, + [NativeTypeName("Uint32 *")] uint* Gmask, + [NativeTypeName("Uint32 *")] uint* Bmask, + [NativeTypeName("Uint32 *")] uint* Amask ) => ( - (delegate* unmanaged)( - _slots[194] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[393] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[194] = nativeContext.LoadFunction("SDL_GetDisplayUsableBounds", "SDL3") + : _slots[393] = nativeContext.LoadFunction("SDL_GetMasksForPixelFormat", "SDL3") ) - )(displayID, rect); + )(format, bpp, Rmask, Gmask, Bmask, Amask); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Rect* rect - ) => DllImport.GetDisplayUsableBounds(displayID, rect); + public static byte GetMasksForPixelFormat( + PixelFormat format, + int* bpp, + [NativeTypeName("Uint32 *")] uint* Rmask, + [NativeTypeName("Uint32 *")] uint* Gmask, + [NativeTypeName("Uint32 *")] uint* Bmask, + [NativeTypeName("Uint32 *")] uint* Amask + ) => DllImport.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect + MaybeBool ISdl.GetMasksForPixelFormat( + PixelFormat format, + Ref bpp, + [NativeTypeName("Uint32 *")] Ref Rmask, + [NativeTypeName("Uint32 *")] Ref Gmask, + [NativeTypeName("Uint32 *")] Ref Bmask, + [NativeTypeName("Uint32 *")] Ref Amask ) { - fixed (Rect* __dsl_rect = rect) + fixed (uint* __dsl_Amask = Amask) + fixed (uint* __dsl_Bmask = Bmask) + fixed (uint* __dsl_Gmask = Gmask) + fixed (uint* __dsl_Rmask = Rmask) + fixed (int* __dsl_bpp = bpp) { return (MaybeBool) - (byte)((ISdl)this).GetDisplayUsableBounds(displayID, __dsl_rect); + (byte) + ((ISdl)this).GetMasksForPixelFormat( + format, + __dsl_bpp, + __dsl_Rmask, + __dsl_Gmask, + __dsl_Bmask, + __dsl_Amask + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetDisplayUsableBounds")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetDisplayUsableBounds( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref rect - ) => DllImport.GetDisplayUsableBounds(displayID, rect); + public static MaybeBool GetMasksForPixelFormat( + PixelFormat format, + Ref bpp, + [NativeTypeName("Uint32 *")] Ref Rmask, + [NativeTypeName("Uint32 *")] Ref Gmask, + [NativeTypeName("Uint32 *")] Ref Bmask, + [NativeTypeName("Uint32 *")] Ref Amask + ) => DllImport.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetError() => (sbyte*)((ISdl)this).GetErrorRaw(); + int ISdl.GetMaxHapticEffects(HapticHandle haptic) => + ( + (delegate* unmanaged)( + _slots[394] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[394] = nativeContext.LoadFunction("SDL_GetMaxHapticEffects", "SDL3") + ) + )(haptic); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetError() => DllImport.GetError(); + public static int GetMaxHapticEffects(HapticHandle haptic) => + DllImport.GetMaxHapticEffects(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetErrorRaw() => + int ISdl.GetMaxHapticEffectsPlaying(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[195] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[395] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[195] = nativeContext.LoadFunction("SDL_GetError", "SDL3") + : _slots[395] = nativeContext.LoadFunction( + "SDL_GetMaxHapticEffectsPlaying", + "SDL3" + ) ) - )(); + )(haptic); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetError")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetErrorRaw() => DllImport.GetErrorRaw(); + public static int GetMaxHapticEffectsPlaying(HapticHandle haptic) => + DllImport.GetMaxHapticEffectsPlaying(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, - void** userdata + void ISdl.GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func ) => ( - (delegate* unmanaged)( - _slots[196] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[396] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[196] = nativeContext.LoadFunction("SDL_GetEventFilter", "SDL3") + : _slots[396] = nativeContext.LoadFunction("SDL_GetMemoryFunctions", "SDL3") ) - )(filter, userdata); + )(malloc_func, calloc_func, realloc_func, free_func); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] EventFilter* filter, - void** userdata - ) => DllImport.GetEventFilter(filter, userdata); + public static void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => DllImport.GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] Ref filter, - Ref2D userdata + void ISdl.GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func ) { - fixed (void** __dsl_userdata = userdata) - fixed (EventFilter* __dsl_filter = filter) - { - return (MaybeBool)(byte)((ISdl)this).GetEventFilter(__dsl_filter, __dsl_userdata); + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) + { + ((ISdl)this).GetMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMemoryFunctions")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetEventFilter( - [NativeTypeName("SDL_EventFilter *")] Ref filter, - Ref2D userdata - ) => DllImport.GetEventFilter(filter, userdata); + public static void GetMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) => DllImport.GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float default_value - ) => + uint* ISdl.GetMice(int* count) => ( - (delegate* unmanaged)( - _slots[197] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[397] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[197] = nativeContext.LoadFunction("SDL_GetFloatProperty", "SDL3") + : _slots[397] = nativeContext.LoadFunction("SDL_GetMice", "SDL3") ) - )(props, name, default_value); + )(count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [return: NativeTypeName("SDL_MouseID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - float default_value - ) => DllImport.GetFloatProperty(props, name, default_value); + public static uint* GetMice(int* count) => DllImport.GetMice(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float default_value - ) + Ptr ISdl.GetMice(Ref count) { - fixed (sbyte* __dsl_name = name) + fixed (int* __dsl_count = count) { - return (float)((ISdl)this).GetFloatProperty(props, __dsl_name, default_value); + return (uint*)((ISdl)this).GetMice(__dsl_count); } } + [return: NativeTypeName("SDL_MouseID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetFloatProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - float default_value - ) => DllImport.GetFloatProperty(props, name, default_value); + public static Ptr GetMice(Ref count) => DllImport.GetMice(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayMode** ISdl.GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int* count - ) => + ushort ISdl.GetModState() => ( - (delegate* unmanaged)( - _slots[198] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[398] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[198] = nativeContext.LoadFunction( - "SDL_GetFullscreenDisplayModes", - "SDL3" - ) + : _slots[398] = nativeContext.LoadFunction("SDL_GetModState", "SDL3") ) - )(displayID, count); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [return: NativeTypeName("SDL_Keymod")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayMode** GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - int* count - ) => DllImport.GetFullscreenDisplayModes(displayID, count); + public static ushort GetModState() => DllImport.GetModState(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref count - ) - { - fixed (int* __dsl_count = count) - { - return (DisplayMode**)((ISdl)this).GetFullscreenDisplayModes(displayID, __dsl_count); - } - } + WindowHandle ISdl.GetMouseFocus() => + ( + (delegate* unmanaged)( + _slots[399] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[399] = nativeContext.LoadFunction("SDL_GetMouseFocus", "SDL3") + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetFullscreenDisplayModes")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetFullscreenDisplayModes( - [NativeTypeName("SDL_DisplayID")] uint displayID, - Ref count - ) => DllImport.GetFullscreenDisplayModes(displayID, count); + public static WindowHandle GetMouseFocus() => DllImport.GetMouseFocus(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadAppleSFSymbolsNameForAxis(GamepadHandle gamepad, GamepadAxis axis) => - (sbyte*)((ISdl)this).GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); + Ptr ISdl.GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => + (sbyte*)((ISdl)this).GetMouseNameForIDRaw(instance_id); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadAppleSFSymbolsNameForAxis( - GamepadHandle gamepad, - GamepadAxis axis - ) => DllImport.GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); + public static Ptr GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => + DllImport.GetMouseNameForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadAppleSFSymbolsNameForAxisRaw(GamepadHandle gamepad, GamepadAxis axis) => + sbyte* ISdl.GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[199] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[400] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[199] = nativeContext.LoadFunction( - "SDL_GetGamepadAppleSFSymbolsNameForAxis", - "SDL3" - ) + : _slots[400] = nativeContext.LoadFunction("SDL_GetMouseNameForID", "SDL3") ) - )(gamepad, axis); + )(instance_id); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadAppleSFSymbolsNameForAxisRaw( - GamepadHandle gamepad, - GamepadAxis axis - ) => DllImport.GetGamepadAppleSFSymbolsNameForAxisRaw(gamepad, axis); + public static sbyte* GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => + DllImport.GetMouseNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadAppleSFSymbolsNameForButton( - GamepadHandle gamepad, - GamepadButton button - ) => (sbyte*)((ISdl)this).GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); + uint ISdl.GetMouseState(float* x, float* y) => + ( + (delegate* unmanaged)( + _slots[401] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[401] = nativeContext.LoadFunction("SDL_GetMouseState", "SDL3") + ) + )(x, y); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint GetMouseState(float* x, float* y) => DllImport.GetMouseState(x, y); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.GetMouseState(Ref x, Ref y) + { + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + { + return (uint)((ISdl)this).GetMouseState(__dsl_x, __dsl_y); + } + } + + [return: NativeTypeName("SDL_MouseButtonFlags")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadAppleSFSymbolsNameForButton( - GamepadHandle gamepad, - GamepadButton button - ) => DllImport.GetGamepadAppleSFSymbolsNameForButton(gamepad, button); + public static uint GetMouseState(Ref x, Ref y) => DllImport.GetMouseState(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadAppleSFSymbolsNameForButtonRaw( - GamepadHandle gamepad, - GamepadButton button + DisplayOrientation ISdl.GetNaturalDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID ) => ( - (delegate* unmanaged)( - _slots[200] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[402] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[200] = nativeContext.LoadFunction( - "SDL_GetGamepadAppleSFSymbolsNameForButton", + : _slots[402] = nativeContext.LoadFunction( + "SDL_GetNaturalDisplayOrientation", "SDL3" ) ) - )(gamepad, button); + )(displayID); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAppleSFSymbolsNameForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadAppleSFSymbolsNameForButtonRaw( - GamepadHandle gamepad, - GamepadButton button - ) => DllImport.GetGamepadAppleSFSymbolsNameForButtonRaw(gamepad, button); + public static DisplayOrientation GetNaturalDisplayOrientation( + [NativeTypeName("SDL_DisplayID")] uint displayID + ) => DllImport.GetNaturalDisplayOrientation(displayID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - short ISdl.GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => + int ISdl.GetNumAllocations() => ( - (delegate* unmanaged)( - _slots[201] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[403] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[201] = nativeContext.LoadFunction("SDL_GetGamepadAxis", "SDL3") + : _slots[403] = nativeContext.LoadFunction("SDL_GetNumAllocations", "SDL3") ) - )(gamepad, axis); + )(); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAllocations")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static short GetGamepadAxis(GamepadHandle gamepad, GamepadAxis axis) => - DllImport.GetGamepadAxis(gamepad, axis); + public static int GetNumAllocations() => DllImport.GetNumAllocations(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadAxis ISdl.GetGamepadAxisFromString([NativeTypeName("const char *")] sbyte* str) => + int ISdl.GetNumAudioDrivers() => ( - (delegate* unmanaged)( - _slots[202] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[404] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[202] = nativeContext.LoadFunction( - "SDL_GetGamepadAxisFromString", - "SDL3" - ) + : _slots[404] = nativeContext.LoadFunction("SDL_GetNumAudioDrivers", "SDL3") ) - )(str); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadAxis GetGamepadAxisFromString( - [NativeTypeName("const char *")] sbyte* str - ) => DllImport.GetGamepadAxisFromString(str); + public static int GetNumAudioDrivers() => DllImport.GetNumAudioDrivers(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadAxis ISdl.GetGamepadAxisFromString([NativeTypeName("const char *")] Ref str) + long ISdl.GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long default_value + ) => + ( + (delegate* unmanaged)( + _slots[405] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[405] = nativeContext.LoadFunction("SDL_GetNumberProperty", "SDL3") + ) + )(props, name, default_value); + + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long default_value + ) => DllImport.GetNumberProperty(props, name, default_value); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + long ISdl.GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long default_value + ) { - fixed (sbyte* __dsl_str = str) + fixed (sbyte* __dsl_name = name) { - return (GamepadAxis)((ISdl)this).GetGamepadAxisFromString(__dsl_str); + return (long)((ISdl)this).GetNumberProperty(props, __dsl_name, default_value); } } + [return: NativeTypeName("Sint64")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadAxisFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadAxis GetGamepadAxisFromString( - [NativeTypeName("const char *")] Ref str - ) => DllImport.GetGamepadAxisFromString(str); + public static long GetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long default_value + ) => DllImport.GetNumberProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadBinding** ISdl.GetGamepadBindings(GamepadHandle gamepad, int* count) => + int ISdl.GetNumCameraDrivers() => ( - (delegate* unmanaged)( - _slots[203] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[406] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[203] = nativeContext.LoadFunction("SDL_GetGamepadBindings", "SDL3") + : _slots[406] = nativeContext.LoadFunction("SDL_GetNumCameraDrivers", "SDL3") ) - )(gamepad, count); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadBinding** GetGamepadBindings(GamepadHandle gamepad, int* count) => - DllImport.GetGamepadBindings(gamepad, count); + public static int GetNumCameraDrivers() => DllImport.GetNumCameraDrivers(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetGamepadBindings(GamepadHandle gamepad, Ref count) - { - fixed (int* __dsl_count = count) - { - return (GamepadBinding**)((ISdl)this).GetGamepadBindings(gamepad, __dsl_count); - } - } + int ISdl.GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => + ( + (delegate* unmanaged)( + _slots[407] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[407] = nativeContext.LoadFunction( + "SDL_GetNumGamepadTouchpadFingers", + "SDL3" + ) + ) + )(gamepad, touchpad); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => + DllImport.GetNumGamepadTouchpadFingers(gamepad, touchpad); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadBindings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetGamepadBindings(GamepadHandle gamepad, Ref count) => - DllImport.GetGamepadBindings(gamepad, count); + int ISdl.GetNumGamepadTouchpads(GamepadHandle gamepad) => + ( + (delegate* unmanaged)( + _slots[408] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[408] = nativeContext.LoadFunction("SDL_GetNumGamepadTouchpads", "SDL3") + ) + )(gamepad); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => - (MaybeBool)(byte)((ISdl)this).GetGamepadButtonRaw(gamepad, button); + public static int GetNumGamepadTouchpads(GamepadHandle gamepad) => + DllImport.GetNumGamepadTouchpads(gamepad); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetGamepadButton(GamepadHandle gamepad, GamepadButton button) => - DllImport.GetGamepadButton(gamepad, button); + int ISdl.GetNumGPUDrivers() => + ( + (delegate* unmanaged)( + _slots[409] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[409] = nativeContext.LoadFunction("SDL_GetNumGPUDrivers", "SDL3") + ) + )(); + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGPUDrivers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadButton ISdl.GetGamepadButtonFromString([NativeTypeName("const char *")] sbyte* str) => + public static int GetNumGPUDrivers() => DllImport.GetNumGPUDrivers(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.GetNumHapticAxes(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[205] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[410] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[205] = nativeContext.LoadFunction( - "SDL_GetGamepadButtonFromString", - "SDL3" - ) + : _slots[410] = nativeContext.LoadFunction("SDL_GetNumHapticAxes", "SDL3") ) - )(str); + )(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] sbyte* str - ) => DllImport.GetGamepadButtonFromString(str); + public static int GetNumHapticAxes(HapticHandle haptic) => DllImport.GetNumHapticAxes(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadButton ISdl.GetGamepadButtonFromString([NativeTypeName("const char *")] Ref str) - { - fixed (sbyte* __dsl_str = str) - { - return (GamepadButton)((ISdl)this).GetGamepadButtonFromString(__dsl_str); - } - } + int ISdl.GetNumJoystickAxes(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[411] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[411] = nativeContext.LoadFunction("SDL_GetNumJoystickAxes", "SDL3") + ) + )(joystick); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadButton GetGamepadButtonFromString( - [NativeTypeName("const char *")] Ref str - ) => DllImport.GetGamepadButtonFromString(str); + public static int GetNumJoystickAxes(JoystickHandle joystick) => + DllImport.GetNumJoystickAxes(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadButtonLabel ISdl.GetGamepadButtonLabel(GamepadHandle gamepad, GamepadButton button) => + int ISdl.GetNumJoystickBalls(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[206] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[412] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[206] = nativeContext.LoadFunction("SDL_GetGamepadButtonLabel", "SDL3") + : _slots[412] = nativeContext.LoadFunction("SDL_GetNumJoystickBalls", "SDL3") ) - )(gamepad, button); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabel")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadButtonLabel GetGamepadButtonLabel( - GamepadHandle gamepad, - GamepadButton button - ) => DllImport.GetGamepadButtonLabel(gamepad, button); + public static int GetNumJoystickBalls(JoystickHandle joystick) => + DllImport.GetNumJoystickBalls(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadButtonLabel ISdl.GetGamepadButtonLabelForType(GamepadType type, GamepadButton button) => + int ISdl.GetNumJoystickButtons(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[207] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[413] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[207] = nativeContext.LoadFunction( - "SDL_GetGamepadButtonLabelForType", - "SDL3" - ) + : _slots[413] = nativeContext.LoadFunction("SDL_GetNumJoystickButtons", "SDL3") ) - )(type, button); + )(joystick); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButtonLabelForType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadButtonLabel GetGamepadButtonLabelForType( - GamepadType type, - GamepadButton button - ) => DllImport.GetGamepadButtonLabelForType(type, button); + public static int GetNumJoystickButtons(JoystickHandle joystick) => + DllImport.GetNumJoystickButtons(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => + int ISdl.GetNumJoystickHats(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[204] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[414] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[204] = nativeContext.LoadFunction("SDL_GetGamepadButton", "SDL3") + : _slots[414] = nativeContext.LoadFunction("SDL_GetNumJoystickHats", "SDL3") ) - )(gamepad, button); + )(joystick); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetGamepadButtonRaw(GamepadHandle gamepad, GamepadButton button) => - DllImport.GetGamepadButtonRaw(gamepad, button); + public static int GetNumJoystickHats(JoystickHandle joystick) => + DllImport.GetNumJoystickHats(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickConnectionState ISdl.GetGamepadConnectionState(GamepadHandle gamepad) => + int ISdl.GetNumLogicalCPUCores() => ( - (delegate* unmanaged)( - _slots[208] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[415] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[208] = nativeContext.LoadFunction( - "SDL_GetGamepadConnectionState", - "SDL3" - ) + : _slots[415] = nativeContext.LoadFunction("SDL_GetNumLogicalCPUCores", "SDL3") ) - )(gamepad); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadConnectionState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickConnectionState GetGamepadConnectionState(GamepadHandle gamepad) => - DllImport.GetGamepadConnectionState(gamepad); + public static int GetNumLogicalCPUCores() => DllImport.GetNumLogicalCPUCores(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadFirmwareVersion(GamepadHandle gamepad) => + int ISdl.GetNumRenderDrivers() => ( - (delegate* unmanaged)( - _slots[209] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[416] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[209] = nativeContext.LoadFunction( - "SDL_GetGamepadFirmwareVersion", - "SDL3" - ) + : _slots[416] = nativeContext.LoadFunction("SDL_GetNumRenderDrivers", "SDL3") ) - )(gamepad); + )(); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFirmwareVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadFirmwareVersion(GamepadHandle gamepad) => - DllImport.GetGamepadFirmwareVersion(gamepad); + public static int GetNumRenderDrivers() => DllImport.GetNumRenderDrivers(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadHandle ISdl.GetGamepadFromID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + int ISdl.GetNumVideoDrivers() => ( - (delegate* unmanaged)( - _slots[210] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[417] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[210] = nativeContext.LoadFunction("SDL_GetGamepadFromID", "SDL3") + : _slots[417] = nativeContext.LoadFunction("SDL_GetNumVideoDrivers", "SDL3") ) - )(instance_id); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadHandle GetGamepadFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadFromID(instance_id); + public static int GetNumVideoDrivers() => DllImport.GetNumVideoDrivers(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadHandle ISdl.GetGamepadFromPlayerIndex(int player_index) => + void ISdl.GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => ( - (delegate* unmanaged)( - _slots[211] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[418] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[211] = nativeContext.LoadFunction( - "SDL_GetGamepadFromPlayerIndex", + : _slots[418] = nativeContext.LoadFunction( + "SDL_GetOriginalMemoryFunctions", "SDL3" ) ) - )(player_index); + )(malloc_func, calloc_func, realloc_func, free_func); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadFromPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadHandle GetGamepadFromPlayerIndex(int player_index) => - DllImport.GetGamepadFromPlayerIndex(player_index); + public static void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] MallocFunc* malloc_func, + [NativeTypeName("SDL_calloc_func *")] CallocFunc* calloc_func, + [NativeTypeName("SDL_realloc_func *")] ReallocFunc* realloc_func, + [NativeTypeName("SDL_free_func *")] FreeFunc* free_func + ) => DllImport.GetOriginalMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Guid ISdl.GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + void ISdl.GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) + { + fixed (FreeFunc* __dsl_free_func = free_func) + fixed (ReallocFunc* __dsl_realloc_func = realloc_func) + fixed (CallocFunc* __dsl_calloc_func = calloc_func) + fixed (MallocFunc* __dsl_malloc_func = malloc_func) + { + ((ISdl)this).GetOriginalMemoryFunctions( + __dsl_malloc_func, + __dsl_calloc_func, + __dsl_realloc_func, + __dsl_free_func + ); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetOriginalMemoryFunctions")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void GetOriginalMemoryFunctions( + [NativeTypeName("SDL_malloc_func *")] Ref malloc_func, + [NativeTypeName("SDL_calloc_func *")] Ref calloc_func, + [NativeTypeName("SDL_realloc_func *")] Ref realloc_func, + [NativeTypeName("SDL_free_func *")] Ref free_func + ) => DllImport.GetOriginalMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => ( - (delegate* unmanaged)( - _slots[212] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[419] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[212] = nativeContext.LoadFunction("SDL_GetGamepadGUIDForID", "SDL3") + : _slots[419] = nativeContext.LoadFunction("SDL_GetPathInfo", "SDL3") ) - )(instance_id); + )(path, info); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadGUIDForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Guid GetGamepadGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.GetGamepadGuidForID(instance_id); + public static byte GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => + DllImport.GetPathInfo(path, info); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetGamepadID(GamepadHandle gamepad) => + MaybeBool ISdl.GetPathInfo( + [NativeTypeName("const char *")] Ref path, + Ref info + ) + { + fixed (PathInfo* __dsl_info = info) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).GetPathInfo(__dsl_path, __dsl_info); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetPathInfo( + [NativeTypeName("const char *")] Ref path, + Ref info + ) => DllImport.GetPathInfo(path, info); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + ulong ISdl.GetPerformanceCounter() => ( - (delegate* unmanaged)( - _slots[213] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[420] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[213] = nativeContext.LoadFunction("SDL_GetGamepadID", "SDL3") + : _slots[420] = nativeContext.LoadFunction("SDL_GetPerformanceCounter", "SDL3") ) - )(gamepad); + )(); - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadID")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetGamepadID(GamepadHandle gamepad) => DllImport.GetGamepadID(gamepad); + public static ulong GetPerformanceCounter() => DllImport.GetPerformanceCounter(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickHandle ISdl.GetGamepadJoystick(GamepadHandle gamepad) => + ulong ISdl.GetPerformanceFrequency() => ( - (delegate* unmanaged)( - _slots[214] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[421] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[214] = nativeContext.LoadFunction("SDL_GetGamepadJoystick", "SDL3") + : _slots[421] = nativeContext.LoadFunction( + "SDL_GetPerformanceFrequency", + "SDL3" + ) ) - )(gamepad); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadJoystick")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickHandle GetGamepadJoystick(GamepadHandle gamepad) => - DllImport.GetGamepadJoystick(gamepad); + public static ulong GetPerformanceFrequency() => DllImport.GetPerformanceFrequency(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadMapping(GamepadHandle gamepad) => - (sbyte*)((ISdl)this).GetGamepadMappingRaw(gamepad); + Ptr ISdl.GetPixelFormatDetails(PixelFormat format) => + (PixelFormatDetails*)((ISdl)this).GetPixelFormatDetailsRaw(format); - [return: NativeTypeName("char *")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadMapping(GamepadHandle gamepad) => - DllImport.GetGamepadMapping(gamepad); + public static Ptr GetPixelFormatDetails(PixelFormat format) => + DllImport.GetPixelFormatDetails(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadMappingForGuid(Guid guid) => - (sbyte*)((ISdl)this).GetGamepadMappingForGuidRaw(guid); + PixelFormatDetails* ISdl.GetPixelFormatDetailsRaw(PixelFormat format) => + ( + (delegate* unmanaged)( + _slots[422] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[422] = nativeContext.LoadFunction("SDL_GetPixelFormatDetails", "SDL3") + ) + )(format); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadMappingForGuid(Guid guid) => - DllImport.GetGamepadMappingForGuid(guid); + public static PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => + DllImport.GetPixelFormatDetailsRaw(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadMappingForGuidRaw(Guid guid) => + PixelFormat ISdl.GetPixelFormatForMasks( + int bpp, + [NativeTypeName("Uint32")] uint Rmask, + [NativeTypeName("Uint32")] uint Gmask, + [NativeTypeName("Uint32")] uint Bmask, + [NativeTypeName("Uint32")] uint Amask + ) => ( - (delegate* unmanaged)( - _slots[216] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[423] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[216] = nativeContext.LoadFunction( - "SDL_GetGamepadMappingForGUID", - "SDL3" - ) + : _slots[423] = nativeContext.LoadFunction("SDL_GetPixelFormatForMasks", "SDL3") ) - )(guid); + )(bpp, Rmask, Gmask, Bmask, Amask); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadMappingForGuidRaw(Guid guid) => - DllImport.GetGamepadMappingForGuidRaw(guid); + public static PixelFormat GetPixelFormatForMasks( + int bpp, + [NativeTypeName("Uint32")] uint Rmask, + [NativeTypeName("Uint32")] uint Gmask, + [NativeTypeName("Uint32")] uint Bmask, + [NativeTypeName("Uint32")] uint Amask + ) => DllImport.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadMappingForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (sbyte*)((ISdl)this).GetGamepadMappingForIDRaw(instance_id); + Ptr ISdl.GetPixelFormatName(PixelFormat format) => + (sbyte*)((ISdl)this).GetPixelFormatNameRaw(format); - [return: NativeTypeName("char *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadMappingForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadMappingForID(instance_id); + public static Ptr GetPixelFormatName(PixelFormat format) => + DllImport.GetPixelFormatName(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadMappingForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + sbyte* ISdl.GetPixelFormatNameRaw(PixelFormat format) => ( - (delegate* unmanaged)( - _slots[217] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[424] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[217] = nativeContext.LoadFunction("SDL_GetGamepadMappingForID", "SDL3") + : _slots[424] = nativeContext.LoadFunction("SDL_GetPixelFormatName", "SDL3") ) - )(instance_id); + )(format); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappingForID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadMappingForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadMappingForIDRaw(instance_id); + public static sbyte* GetPixelFormatNameRaw(PixelFormat format) => + DllImport.GetPixelFormatNameRaw(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadMappingRaw(GamepadHandle gamepad) => + Ptr ISdl.GetPlatform() => (sbyte*)((ISdl)this).GetPlatformRaw(); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetPlatform() => DllImport.GetPlatform(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetPlatformRaw() => ( - (delegate* unmanaged)( - _slots[215] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[425] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[215] = nativeContext.LoadFunction("SDL_GetGamepadMapping", "SDL3") + : _slots[425] = nativeContext.LoadFunction("SDL_GetPlatform", "SDL3") ) - )(gamepad); + )(); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMapping")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadMappingRaw(GamepadHandle gamepad) => - DllImport.GetGamepadMappingRaw(gamepad); + public static sbyte* GetPlatformRaw() => DllImport.GetPlatformRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte** ISdl.GetGamepadMappings(int* count) => + void* ISdl.GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* default_value + ) => ( - (delegate* unmanaged)( - _slots[218] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[426] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[218] = nativeContext.LoadFunction("SDL_GetGamepadMappings", "SDL3") + : _slots[426] = nativeContext.LoadFunction("SDL_GetPointerProperty", "SDL3") ) - )(count); + )(props, name, default_value); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte** GetGamepadMappings(int* count) => DllImport.GetGamepadMappings(count); + public static void* GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* default_value + ) => DllImport.GetPointerProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetGamepadMappings(Ref count) + Ptr ISdl.GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref default_value + ) { - fixed (int* __dsl_count = count) + fixed (void* __dsl_default_value = default_value) + fixed (sbyte* __dsl_name = name) { - return (sbyte**)((ISdl)this).GetGamepadMappings(__dsl_count); + return (void*)((ISdl)this).GetPointerProperty(props, __dsl_name, __dsl_default_value); } } - [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetGamepadMappings(Ref count) => - DllImport.GetGamepadMappings(count); + public static Ptr GetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref default_value + ) => DllImport.GetPointerProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadName(GamepadHandle gamepad) => - (sbyte*)((ISdl)this).GetGamepadNameRaw(gamepad); + PowerState ISdl.GetPowerInfo(int* seconds, int* percent) => + ( + (delegate* unmanaged)( + _slots[427] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[427] = nativeContext.LoadFunction("SDL_GetPowerInfo", "SDL3") + ) + )(seconds, percent); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadName(GamepadHandle gamepad) => - DllImport.GetGamepadName(gamepad); + public static PowerState GetPowerInfo(int* seconds, int* percent) => + DllImport.GetPowerInfo(seconds, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadNameForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (sbyte*)((ISdl)this).GetGamepadNameForIDRaw(instance_id); + PowerState ISdl.GetPowerInfo(Ref seconds, Ref percent) + { + fixed (int* __dsl_percent = percent) + fixed (int* __dsl_seconds = seconds) + { + return (PowerState)((ISdl)this).GetPowerInfo(__dsl_seconds, __dsl_percent); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadNameForID(instance_id); + public static PowerState GetPowerInfo(Ref seconds, Ref percent) => + DllImport.GetPowerInfo(seconds, percent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + Locale** ISdl.GetPreferredLocales(int* count) => ( - (delegate* unmanaged)( - _slots[220] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[428] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[220] = nativeContext.LoadFunction("SDL_GetGamepadNameForID", "SDL3") + : _slots[428] = nativeContext.LoadFunction("SDL_GetPreferredLocales", "SDL3") ) - )(instance_id); + )(count); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadNameForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadNameForIDRaw(instance_id); + public static Locale** GetPreferredLocales(int* count) => DllImport.GetPreferredLocales(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadNameRaw(GamepadHandle gamepad) => + Ptr2D ISdl.GetPreferredLocales(Ref count) + { + fixed (int* __dsl_count = count) + { + return (Locale**)((ISdl)this).GetPreferredLocales(__dsl_count); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr2D GetPreferredLocales(Ref count) => + DllImport.GetPreferredLocales(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetPrefPath( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app + ) => ( - (delegate* unmanaged)( - _slots[219] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[429] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[219] = nativeContext.LoadFunction("SDL_GetGamepadName", "SDL3") + : _slots[429] = nativeContext.LoadFunction("SDL_GetPrefPath", "SDL3") ) - )(gamepad); + )(org, app); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadName")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadNameRaw(GamepadHandle gamepad) => - DllImport.GetGamepadNameRaw(gamepad); + public static sbyte* GetPrefPath( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app + ) => DllImport.GetPrefPath(org, app); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetPrefPath( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app + ) + { + fixed (sbyte* __dsl_app = app) + fixed (sbyte* __dsl_org = org) + { + return (sbyte*)((ISdl)this).GetPrefPath(__dsl_org, __dsl_app); + } + } + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetPrefPath( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app + ) => DllImport.GetPrefPath(org, app); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadPath(GamepadHandle gamepad) => - (sbyte*)((ISdl)this).GetGamepadPathRaw(gamepad); + uint ISdl.GetPrimaryDisplay() => + ( + (delegate* unmanaged)( + _slots[430] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[430] = nativeContext.LoadFunction("SDL_GetPrimaryDisplay", "SDL3") + ) + )(); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [return: NativeTypeName("SDL_DisplayID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadPath(GamepadHandle gamepad) => - DllImport.GetGamepadPath(gamepad); + public static uint GetPrimaryDisplay() => DllImport.GetPrimaryDisplay(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadPathForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (sbyte*)((ISdl)this).GetGamepadPathForIDRaw(instance_id); + Ptr ISdl.GetPrimarySelectionText() => (sbyte*)((ISdl)this).GetPrimarySelectionTextRaw(); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadPathForID(instance_id); + public static Ptr GetPrimarySelectionText() => DllImport.GetPrimarySelectionText(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + sbyte* ISdl.GetPrimarySelectionTextRaw() => ( - (delegate* unmanaged)( - _slots[222] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[431] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[222] = nativeContext.LoadFunction("SDL_GetGamepadPathForID", "SDL3") + : _slots[431] = nativeContext.LoadFunction( + "SDL_GetPrimarySelectionText", + "SDL3" + ) ) - )(instance_id); + )(); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPathForID")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadPathForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadPathForIDRaw(instance_id); + public static sbyte* GetPrimarySelectionTextRaw() => DllImport.GetPrimarySelectionTextRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadPathRaw(GamepadHandle gamepad) => + IOStreamHandle ISdl.GetProcessInput(ProcessHandle process) => ( - (delegate* unmanaged)( - _slots[221] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[432] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[221] = nativeContext.LoadFunction("SDL_GetGamepadPath", "SDL3") + : _slots[432] = nativeContext.LoadFunction("SDL_GetProcessInput", "SDL3") ) - )(gamepad); + )(process); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessInput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadPathRaw(GamepadHandle gamepad) => - DllImport.GetGamepadPathRaw(gamepad); + public static IOStreamHandle GetProcessInput(ProcessHandle process) => + DllImport.GetProcessInput(process); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetGamepadPlayerIndex(GamepadHandle gamepad) => + IOStreamHandle ISdl.GetProcessOutput(ProcessHandle process) => ( - (delegate* unmanaged)( - _slots[223] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[433] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[223] = nativeContext.LoadFunction("SDL_GetGamepadPlayerIndex", "SDL3") + : _slots[433] = nativeContext.LoadFunction("SDL_GetProcessOutput", "SDL3") ) - )(gamepad); + )(process); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessOutput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetGamepadPlayerIndex(GamepadHandle gamepad) => - DllImport.GetGamepadPlayerIndex(gamepad); + public static IOStreamHandle GetProcessOutput(ProcessHandle process) => + DllImport.GetProcessOutput(process); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetGamepadPlayerIndexForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + uint ISdl.GetProcessProperties(ProcessHandle process) => ( - (delegate* unmanaged)( - _slots[224] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[434] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[224] = nativeContext.LoadFunction( - "SDL_GetGamepadPlayerIndexForID", - "SDL3" - ) + : _slots[434] = nativeContext.LoadFunction("SDL_GetProcessProperties", "SDL3") ) - )(instance_id); + )(process); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPlayerIndexForID")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetProcessProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetGamepadPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadPlayerIndexForID(instance_id); + public static uint GetProcessProperties(ProcessHandle process) => + DllImport.GetProcessProperties(process); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => + PropertyType ISdl.GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => ( - (delegate* unmanaged)( - _slots[225] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[435] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[225] = nativeContext.LoadFunction("SDL_GetGamepadPowerInfo", "SDL3") + : _slots[435] = nativeContext.LoadFunction("SDL_GetPropertyType", "SDL3") ) - )(gamepad, percent); + )(props, name); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, int* percent) => - DllImport.GetGamepadPowerInfo(gamepad, percent); + public static PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.GetPropertyType(props, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) + PropertyType ISdl.GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) { - fixed (int* __dsl_percent = percent) + fixed (sbyte* __dsl_name = name) { - return (PowerState)((ISdl)this).GetGamepadPowerInfo(gamepad, __dsl_percent); + return (PropertyType)((ISdl)this).GetPropertyType(props, __dsl_name); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetGamepadPowerInfo(GamepadHandle gamepad, Ref percent) => - DllImport.GetGamepadPowerInfo(gamepad, percent); + public static PropertyType GetPropertyType( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => DllImport.GetPropertyType(props, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadProduct(GamepadHandle gamepad) => + GamepadType ISdl.GetRealGamepadType(GamepadHandle gamepad) => ( - (delegate* unmanaged)( - _slots[226] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[436] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[226] = nativeContext.LoadFunction("SDL_GetGamepadProduct", "SDL3") + : _slots[436] = nativeContext.LoadFunction("SDL_GetRealGamepadType", "SDL3") ) )(gamepad); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProduct")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadProduct(GamepadHandle gamepad) => - DllImport.GetGamepadProduct(gamepad); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[227] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[227] = nativeContext.LoadFunction("SDL_GetGamepadProductForID", "SDL3") - ) - )(instance_id); - - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadProductForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadProductForID(instance_id); + public static GamepadType GetRealGamepadType(GamepadHandle gamepad) => + DllImport.GetRealGamepadType(gamepad); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadProductVersion(GamepadHandle gamepad) => + GamepadType ISdl.GetRealGamepadTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[228] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[437] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[228] = nativeContext.LoadFunction( - "SDL_GetGamepadProductVersion", + : _slots[437] = nativeContext.LoadFunction( + "SDL_GetRealGamepadTypeForID", "SDL3" ) ) - )(gamepad); + )(instance_id); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadProductVersion(GamepadHandle gamepad) => - DllImport.GetGamepadProductVersion(gamepad); + public static GamepadType GetRealGamepadTypeForID( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.GetRealGamepadTypeForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id + byte ISdl.GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int* X1, + int* Y1, + int* X2, + int* Y2 ) => ( - (delegate* unmanaged)( - _slots[229] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[438] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[229] = nativeContext.LoadFunction( - "SDL_GetGamepadProductVersionForID", + : _slots[438] = nativeContext.LoadFunction( + "SDL_GetRectAndLineIntersection", "SDL3" ) ) - )(instance_id); + )(rect, X1, Y1, X2, Y2); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProductVersionForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadProductVersionForID(instance_id); + public static byte GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int* X1, + int* Y1, + int* X2, + int* Y2 + ) => DllImport.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetGamepadProperties(GamepadHandle gamepad) => - ( - (delegate* unmanaged)( - _slots[230] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[230] = nativeContext.LoadFunction("SDL_GetGamepadProperties", "SDL3") - ) - )(gamepad); + MaybeBool ISdl.GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) + { + fixed (int* __dsl_Y2 = Y2) + fixed (int* __dsl_X2 = X2) + fixed (int* __dsl_Y1 = Y1) + fixed (int* __dsl_X1 = X1) + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool) + (byte) + ((ISdl)this).GetRectAndLineIntersection( + __dsl_rect, + __dsl_X1, + __dsl_Y1, + __dsl_X2, + __dsl_Y2 + ); + } + } - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetGamepadProperties(GamepadHandle gamepad) => - DllImport.GetGamepadProperties(gamepad); + public static MaybeBool GetRectAndLineIntersection( + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) => DllImport.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetGamepads(int* count) => + byte ISdl.GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* rect, + float* X1, + float* Y1, + float* X2, + float* Y2 + ) => ( - (delegate* unmanaged)( - _slots[231] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[439] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[231] = nativeContext.LoadFunction("SDL_GetGamepads", "SDL3") + : _slots[439] = nativeContext.LoadFunction( + "SDL_GetRectAndLineIntersectionFloat", + "SDL3" + ) ) - )(count); + )(rect, X1, Y1, X2, Y2); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetGamepads(int* count) => DllImport.GetGamepads(count); + public static byte GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* rect, + float* X1, + float* Y1, + float* X2, + float* Y2 + ) => DllImport.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepads(Ref count) + MaybeBool ISdl.GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) { - fixed (int* __dsl_count = count) + fixed (float* __dsl_Y2 = Y2) + fixed (float* __dsl_X2 = X2) + fixed (float* __dsl_Y1 = Y1) + fixed (float* __dsl_X1 = X1) + fixed (FRect* __dsl_rect = rect) { - return (uint*)((ISdl)this).GetGamepads(__dsl_count); + return (MaybeBool) + (byte) + ((ISdl)this).GetRectAndLineIntersectionFloat( + __dsl_rect, + __dsl_X1, + __dsl_Y1, + __dsl_X2, + __dsl_Y2 + ); } } - [return: NativeTypeName("SDL_JoystickID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepads")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepads(Ref count) => DllImport.GetGamepads(count); + public static MaybeBool GetRectAndLineIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref rect, + Ref X1, + Ref Y1, + Ref X2, + Ref Y2 + ) => DllImport.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - float* data, - int num_values + byte ISdl.GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Point* points, + int count, + [NativeTypeName("const SDL_Rect *")] Rect* clip, + Rect* result ) => ( - (delegate* unmanaged)( - _slots[232] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[440] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[232] = nativeContext.LoadFunction("SDL_GetGamepadSensorData", "SDL3") + : _slots[440] = nativeContext.LoadFunction("SDL_GetRectEnclosingPoints", "SDL3") ) - )(gamepad, type, data, num_values); + )(points, count, clip, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - float* data, - int num_values - ) => DllImport.GetGamepadSensorData(gamepad, type, data, num_values); + public static byte GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Point* points, + int count, + [NativeTypeName("const SDL_Rect *")] Rect* clip, + Rect* result + ) => DllImport.GetRectEnclosingPoints(points, count, clip, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - Ref data, - int num_values + MaybeBool ISdl.GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Ref points, + int count, + [NativeTypeName("const SDL_Rect *")] Ref clip, + Ref result ) { - fixed (float* __dsl_data = data) + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_clip = clip) + fixed (Point* __dsl_points = points) { return (MaybeBool) - (byte)((ISdl)this).GetGamepadSensorData(gamepad, type, __dsl_data, num_values); + (byte) + ((ISdl)this).GetRectEnclosingPoints( + __dsl_points, + count, + __dsl_clip, + __dsl_result + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetGamepadSensorData( - GamepadHandle gamepad, - SensorType type, - Ref data, - int num_values - ) => DllImport.GetGamepadSensorData(gamepad, type, data, num_values); + public static MaybeBool GetRectEnclosingPoints( + [NativeTypeName("const SDL_Point *")] Ref points, + int count, + [NativeTypeName("const SDL_Rect *")] Ref clip, + Ref result + ) => DllImport.GetRectEnclosingPoints(points, count, clip, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => + byte ISdl.GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count, + [NativeTypeName("const SDL_FRect *")] FRect* clip, + FRect* result + ) => ( - (delegate* unmanaged)( - _slots[233] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[441] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[233] = nativeContext.LoadFunction( - "SDL_GetGamepadSensorDataRate", + : _slots[441] = nativeContext.LoadFunction( + "SDL_GetRectEnclosingPointsFloat", "SDL3" ) ) - )(gamepad, type); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSensorDataRate")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetGamepadSensorDataRate(GamepadHandle gamepad, SensorType type) => - DllImport.GetGamepadSensorDataRate(gamepad, type); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadSerial(GamepadHandle gamepad) => - (sbyte*)((ISdl)this).GetGamepadSerialRaw(gamepad); - - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadSerial(GamepadHandle gamepad) => - DllImport.GetGamepadSerial(gamepad); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadSerialRaw(GamepadHandle gamepad) => - ( - (delegate* unmanaged)( - _slots[234] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[234] = nativeContext.LoadFunction("SDL_GetGamepadSerial", "SDL3") - ) - )(gamepad); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSerial")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadSerialRaw(GamepadHandle gamepad) => - DllImport.GetGamepadSerialRaw(gamepad); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetGamepadSteamHandle(GamepadHandle gamepad) => - ( - (delegate* unmanaged)( - _slots[235] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[235] = nativeContext.LoadFunction("SDL_GetGamepadSteamHandle", "SDL3") - ) - )(gamepad); + )(points, count, clip, result); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadSteamHandle")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetGamepadSteamHandle(GamepadHandle gamepad) => - DllImport.GetGamepadSteamHandle(gamepad); + public static byte GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count, + [NativeTypeName("const SDL_FRect *")] FRect* clip, + FRect* result + ) => DllImport.GetRectEnclosingPointsFloat(points, count, clip, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadStringForAxis(GamepadAxis axis) => - (sbyte*)((ISdl)this).GetGamepadStringForAxisRaw(axis); + MaybeBool ISdl.GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count, + [NativeTypeName("const SDL_FRect *")] Ref clip, + Ref result + ) + { + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_clip = clip) + fixed (FPoint* __dsl_points = points) + { + return (MaybeBool) + (byte) + ((ISdl)this).GetRectEnclosingPointsFloat( + __dsl_points, + count, + __dsl_clip, + __dsl_result + ); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadStringForAxis(GamepadAxis axis) => - DllImport.GetGamepadStringForAxis(axis); + public static MaybeBool GetRectEnclosingPointsFloat( + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count, + [NativeTypeName("const SDL_FRect *")] Ref clip, + Ref result + ) => DllImport.GetRectEnclosingPointsFloat(points, count, clip, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadStringForAxisRaw(GamepadAxis axis) => + byte ISdl.GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => ( - (delegate* unmanaged)( - _slots[236] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[442] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[236] = nativeContext.LoadFunction( - "SDL_GetGamepadStringForAxis", - "SDL3" - ) + : _slots[442] = nativeContext.LoadFunction("SDL_GetRectIntersection", "SDL3") ) - )(axis); + )(A, B, result); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForAxis")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadStringForAxisRaw(GamepadAxis axis) => - DllImport.GetGamepadStringForAxisRaw(axis); + public static byte GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => DllImport.GetRectIntersection(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadStringForButton(GamepadButton button) => - (sbyte*)((ISdl)this).GetGamepadStringForButtonRaw(button); + MaybeBool ISdl.GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) + { + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) + { + return (MaybeBool) + (byte)((ISdl)this).GetRectIntersection(__dsl_A, __dsl_B, __dsl_result); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadStringForButton(GamepadButton button) => - DllImport.GetGamepadStringForButton(button); + public static MaybeBool GetRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) => DllImport.GetRectIntersection(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadStringForButtonRaw(GamepadButton button) => + byte ISdl.GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => ( - (delegate* unmanaged)( - _slots[237] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[443] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[237] = nativeContext.LoadFunction( - "SDL_GetGamepadStringForButton", + : _slots[443] = nativeContext.LoadFunction( + "SDL_GetRectIntersectionFloat", "SDL3" ) ) - )(button); + )(A, B, result); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForButton")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadStringForButtonRaw(GamepadButton button) => - DllImport.GetGamepadStringForButtonRaw(button); + public static byte GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => DllImport.GetRectIntersectionFloat(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetGamepadStringForType(GamepadType type) => - (sbyte*)((ISdl)this).GetGamepadStringForTypeRaw(type); + MaybeBool ISdl.GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) + { + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) + { + return (MaybeBool) + (byte)((ISdl)this).GetRectIntersectionFloat(__dsl_A, __dsl_B, __dsl_result); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetGamepadStringForType(GamepadType type) => - DllImport.GetGamepadStringForType(type); + public static MaybeBool GetRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) => DllImport.GetRectIntersectionFloat(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetGamepadStringForTypeRaw(GamepadType type) => + byte ISdl.GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => ( - (delegate* unmanaged)( - _slots[238] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[444] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[238] = nativeContext.LoadFunction( - "SDL_GetGamepadStringForType", - "SDL3" - ) + : _slots[444] = nativeContext.LoadFunction("SDL_GetRectUnion", "SDL3") ) - )(type); + )(A, B, result); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadStringForType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetGamepadStringForTypeRaw(GamepadType type) => - DllImport.GetGamepadStringForTypeRaw(type); + public static byte GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B, + Rect* result + ) => DllImport.GetRectUnion(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - bool* down, - float* x, - float* y, - float* pressure + MaybeBool ISdl.GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) + { + fixed (Rect* __dsl_result = result) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) + { + return (MaybeBool)(byte)((ISdl)this).GetRectUnion(__dsl_A, __dsl_B, __dsl_result); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetRectUnion( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B, + Ref result + ) => DllImport.GetRectUnion(A, B, result); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result ) => ( - (delegate* unmanaged)( - _slots[239] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[445] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[239] = nativeContext.LoadFunction( - "SDL_GetGamepadTouchpadFinger", - "SDL3" - ) + : _slots[445] = nativeContext.LoadFunction("SDL_GetRectUnionFloat", "SDL3") ) - )(gamepad, touchpad, finger, down, x, y, pressure); + )(A, B, result); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - bool* down, - float* x, - float* y, - float* pressure - ) => DllImport.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); + public static byte GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B, + FRect* result + ) => DllImport.GetRectUnionFloat(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - Ref down, - Ref x, - Ref y, - Ref pressure + MaybeBool ISdl.GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result ) { - fixed (float* __dsl_pressure = pressure) - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) - fixed (bool* __dsl_down = down) + fixed (FRect* __dsl_result = result) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) { return (MaybeBool) - (byte) - ((ISdl)this).GetGamepadTouchpadFinger( - gamepad, - touchpad, - finger, - __dsl_down, - __dsl_x, - __dsl_y, - __dsl_pressure - ); + (byte)((ISdl)this).GetRectUnionFloat(__dsl_A, __dsl_B, __dsl_result); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTouchpadFinger")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetGamepadTouchpadFinger( - GamepadHandle gamepad, - int touchpad, - int finger, - Ref down, - Ref x, - Ref y, - Ref pressure - ) => DllImport.GetGamepadTouchpadFinger(gamepad, touchpad, finger, down, x, y, pressure); + public static MaybeBool GetRectUnionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B, + Ref result + ) => DllImport.GetRectUnionFloat(A, B, result); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetGamepadType(GamepadHandle gamepad) => + uint ISdl.GetRelativeMouseState(float* x, float* y) => ( - (delegate* unmanaged)( - _slots[240] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[446] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[240] = nativeContext.LoadFunction("SDL_GetGamepadType", "SDL3") + : _slots[446] = nativeContext.LoadFunction("SDL_GetRelativeMouseState", "SDL3") ) - )(gamepad); + )(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadType")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetGamepadType(GamepadHandle gamepad) => - DllImport.GetGamepadType(gamepad); + public static uint GetRelativeMouseState(float* x, float* y) => + DllImport.GetRelativeMouseState(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetGamepadTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[241] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[241] = nativeContext.LoadFunction("SDL_GetGamepadTypeForID", "SDL3") - ) - )(instance_id); + uint ISdl.GetRelativeMouseState(Ref x, Ref y) + { + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) + { + return (uint)((ISdl)this).GetRelativeMouseState(__dsl_x, __dsl_y); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeForID")] + [return: NativeTypeName("SDL_MouseButtonFlags")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadTypeForID(instance_id); + public static uint GetRelativeMouseState(Ref x, Ref y) => + DllImport.GetRelativeMouseState(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetGamepadTypeFromString([NativeTypeName("const char *")] sbyte* str) => + byte ISdl.GetRenderClipRect(RendererHandle renderer, Rect* rect) => ( - (delegate* unmanaged)( - _slots[242] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[447] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[242] = nativeContext.LoadFunction( - "SDL_GetGamepadTypeFromString", - "SDL3" - ) + : _slots[447] = nativeContext.LoadFunction("SDL_GetRenderClipRect", "SDL3") ) - )(str); + )(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetGamepadTypeFromString( - [NativeTypeName("const char *")] sbyte* str - ) => DllImport.GetGamepadTypeFromString(str); + public static byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => + DllImport.GetRenderClipRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetGamepadTypeFromString([NativeTypeName("const char *")] Ref str) + MaybeBool ISdl.GetRenderClipRect(RendererHandle renderer, Ref rect) { - fixed (sbyte* __dsl_str = str) + fixed (Rect* __dsl_rect = rect) { - return (GamepadType)((ISdl)this).GetGamepadTypeFromString(__dsl_str); + return (MaybeBool)(byte)((ISdl)this).GetRenderClipRect(renderer, __dsl_rect); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadTypeFromString")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetGamepadTypeFromString( - [NativeTypeName("const char *")] Ref str - ) => DllImport.GetGamepadTypeFromString(str); + public static MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) => + DllImport.GetRenderClipRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadVendor(GamepadHandle gamepad) => + byte ISdl.GetRenderColorScale(RendererHandle renderer, float* scale) => ( - (delegate* unmanaged)( - _slots[243] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[448] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[243] = nativeContext.LoadFunction("SDL_GetGamepadVendor", "SDL3") + : _slots[448] = nativeContext.LoadFunction("SDL_GetRenderColorScale", "SDL3") ) - )(gamepad); + )(renderer, scale); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadVendor(GamepadHandle gamepad) => - DllImport.GetGamepadVendor(gamepad); + public static byte GetRenderColorScale(RendererHandle renderer, float* scale) => + DllImport.GetRenderColorScale(renderer, scale); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetGamepadVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[244] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[244] = nativeContext.LoadFunction("SDL_GetGamepadVendorForID", "SDL3") - ) - )(instance_id); + MaybeBool ISdl.GetRenderColorScale(RendererHandle renderer, Ref scale) + { + fixed (float* __dsl_scale = scale) + { + return (MaybeBool)(byte)((ISdl)this).GetRenderColorScale(renderer, __dsl_scale); + } + } - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGamepadVendorForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetGamepadVendorForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetGamepadVendorForID(instance_id); + public static MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) => + DllImport.GetRenderColorScale(renderer, scale); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetGlobalMouseState(float* x, float* y) => + byte ISdl.GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => ( - (delegate* unmanaged)( - _slots[245] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[449] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[245] = nativeContext.LoadFunction("SDL_GetGlobalMouseState", "SDL3") + : _slots[449] = nativeContext.LoadFunction("SDL_GetRenderDrawBlendMode", "SDL3") ) - )(x, y); + )(renderer, blendMode); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetGlobalMouseState(float* x, float* y) => - DllImport.GetGlobalMouseState(x, y); + public static byte GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => DllImport.GetRenderDrawBlendMode(renderer, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetGlobalMouseState(Ref x, Ref y) + MaybeBool ISdl.GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) + fixed (BlendMode* __dsl_blendMode = blendMode) { - return (uint)((ISdl)this).GetGlobalMouseState(__dsl_x, __dsl_y); + return (MaybeBool) + (byte)((ISdl)this).GetRenderDrawBlendMode(renderer, __dsl_blendMode); } } - [return: NativeTypeName("SDL_MouseButtonFlags")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetGlobalMouseState(Ref x, Ref y) => - DllImport.GetGlobalMouseState(x, y); + public static MaybeBool GetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => DllImport.GetRenderDrawBlendMode(renderer, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetGlobalProperties() => + byte ISdl.GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => ( - (delegate* unmanaged)( - _slots[246] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[450] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[246] = nativeContext.LoadFunction("SDL_GetGlobalProperties", "SDL3") + : _slots[450] = nativeContext.LoadFunction("SDL_GetRenderDrawColor", "SDL3") ) - )(); + )(renderer, r, g, b, a); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetGlobalProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetGlobalProperties() => DllImport.GetGlobalProperties(); + public static byte GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => DllImport.GetRenderDrawColor(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetGrabbedWindow() => + MaybeBool ISdl.GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) + { + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + { + return (MaybeBool) + (byte)((ISdl)this).GetRenderDrawColor(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => DllImport.GetRenderDrawColor(renderer, r, g, b, a); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetRenderDrawColorFloat( + RendererHandle renderer, + float* r, + float* g, + float* b, + float* a + ) => ( - (delegate* unmanaged)( - _slots[247] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[451] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[247] = nativeContext.LoadFunction("SDL_GetGrabbedWindow", "SDL3") + : _slots[451] = nativeContext.LoadFunction( + "SDL_GetRenderDrawColorFloat", + "SDL3" + ) ) - )(); + )(renderer, r, g, b, a); - [NativeFunction("SDL3", EntryPoint = "SDL_GetGrabbedWindow")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetGrabbedWindow() => DllImport.GetGrabbedWindow(); + public static byte GetRenderDrawColorFloat( + RendererHandle renderer, + float* r, + float* g, + float* b, + float* a + ) => DllImport.GetRenderDrawColorFloat(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetHapticEffectStatus(HapticHandle haptic, int effect) => - (MaybeBool)(byte)((ISdl)this).GetHapticEffectStatusRaw(haptic, effect); + MaybeBool ISdl.GetRenderDrawColorFloat( + RendererHandle renderer, + Ref r, + Ref g, + Ref b, + Ref a + ) + { + fixed (float* __dsl_a = a) + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) + { + return (MaybeBool) + (byte) + ((ISdl)this).GetRenderDrawColorFloat( + renderer, + __dsl_r, + __dsl_g, + __dsl_b, + __dsl_a + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetHapticEffectStatus(HapticHandle haptic, int effect) => - DllImport.GetHapticEffectStatus(haptic, effect); + public static MaybeBool GetRenderDrawColorFloat( + RendererHandle renderer, + Ref r, + Ref g, + Ref b, + Ref a + ) => DllImport.GetRenderDrawColorFloat(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => - ( - (delegate* unmanaged)( - _slots[248] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[248] = nativeContext.LoadFunction("SDL_GetHapticEffectStatus", "SDL3") - ) - )(haptic, effect); + Ptr ISdl.GetRenderDriver(int index) => (sbyte*)((ISdl)this).GetRenderDriverRaw(index); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticEffectStatus")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetHapticEffectStatusRaw(HapticHandle haptic, int effect) => - DllImport.GetHapticEffectStatusRaw(haptic, effect); + public static Ptr GetRenderDriver(int index) => DllImport.GetRenderDriver(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetHapticFeatures(HapticHandle haptic) => + sbyte* ISdl.GetRenderDriverRaw(int index) => ( - (delegate* unmanaged)( - _slots[249] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[452] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[249] = nativeContext.LoadFunction("SDL_GetHapticFeatures", "SDL3") + : _slots[452] = nativeContext.LoadFunction("SDL_GetRenderDriver", "SDL3") ) - )(haptic); + )(index); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFeatures")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetHapticFeatures(HapticHandle haptic) => - DllImport.GetHapticFeatures(haptic); + public static sbyte* GetRenderDriverRaw(int index) => DllImport.GetRenderDriverRaw(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HapticHandle ISdl.GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => + RendererHandle ISdl.GetRenderer(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[250] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[453] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[250] = nativeContext.LoadFunction("SDL_GetHapticFromID", "SDL3") + : _slots[453] = nativeContext.LoadFunction("SDL_GetRenderer", "SDL3") ) - )(instance_id); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticFromID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HapticHandle GetHapticFromID([NativeTypeName("SDL_HapticID")] uint instance_id) => - DllImport.GetHapticFromID(instance_id); + public static RendererHandle GetRenderer(WindowHandle window) => DllImport.GetRenderer(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetHapticID(HapticHandle haptic) => + RendererHandle ISdl.GetRendererFromTexture(Texture* texture) => ( - (delegate* unmanaged)( - _slots[251] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[454] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[251] = nativeContext.LoadFunction("SDL_GetHapticID", "SDL3") + : _slots[454] = nativeContext.LoadFunction("SDL_GetRendererFromTexture", "SDL3") ) - )(haptic); + )(texture); - [return: NativeTypeName("SDL_HapticID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetHapticID(HapticHandle haptic) => DllImport.GetHapticID(haptic); + public static RendererHandle GetRendererFromTexture(Texture* texture) => + DllImport.GetRendererFromTexture(texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetHapticName(HapticHandle haptic) => - (sbyte*)((ISdl)this).GetHapticNameRaw(haptic); + RendererHandle ISdl.GetRendererFromTexture(Ref texture) + { + fixed (Texture* __dsl_texture = texture) + { + return (RendererHandle)((ISdl)this).GetRendererFromTexture(__dsl_texture); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetHapticName(HapticHandle haptic) => DllImport.GetHapticName(haptic); + public static RendererHandle GetRendererFromTexture(Ref texture) => + DllImport.GetRendererFromTexture(texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetHapticNameForID([NativeTypeName("SDL_HapticID")] uint instance_id) => - (sbyte*)((ISdl)this).GetHapticNameForIDRaw(instance_id); + Ptr ISdl.GetRendererName(RendererHandle renderer) => + (sbyte*)((ISdl)this).GetRendererNameRaw(renderer); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetHapticNameForID( - [NativeTypeName("SDL_HapticID")] uint instance_id - ) => DllImport.GetHapticNameForID(instance_id); + public static Ptr GetRendererName(RendererHandle renderer) => + DllImport.GetRendererName(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => + sbyte* ISdl.GetRendererNameRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[253] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[455] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[253] = nativeContext.LoadFunction("SDL_GetHapticNameForID", "SDL3") + : _slots[455] = nativeContext.LoadFunction("SDL_GetRendererName", "SDL3") ) - )(instance_id); + )(renderer); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetHapticNameForIDRaw([NativeTypeName("SDL_HapticID")] uint instance_id) => - DllImport.GetHapticNameForIDRaw(instance_id); + public static sbyte* GetRendererNameRaw(RendererHandle renderer) => + DllImport.GetRendererNameRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetHapticNameRaw(HapticHandle haptic) => + uint ISdl.GetRendererProperties(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[252] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[456] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[252] = nativeContext.LoadFunction("SDL_GetHapticName", "SDL3") + : _slots[456] = nativeContext.LoadFunction("SDL_GetRendererProperties", "SDL3") ) - )(haptic); + )(renderer); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHapticName")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetHapticNameRaw(HapticHandle haptic) => - DllImport.GetHapticNameRaw(haptic); + public static uint GetRendererProperties(RendererHandle renderer) => + DllImport.GetRendererProperties(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetHaptics(int* count) => + byte ISdl.GetRenderLogicalPresentation( + RendererHandle renderer, + int* w, + int* h, + RendererLogicalPresentation* mode + ) => ( - (delegate* unmanaged)( - _slots[254] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[457] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[254] = nativeContext.LoadFunction("SDL_GetHaptics", "SDL3") + : _slots[457] = nativeContext.LoadFunction( + "SDL_GetRenderLogicalPresentation", + "SDL3" + ) ) - )(count); + )(renderer, w, h, mode); - [return: NativeTypeName("SDL_HapticID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetHaptics(int* count) => DllImport.GetHaptics(count); + public static byte GetRenderLogicalPresentation( + RendererHandle renderer, + int* w, + int* h, + RendererLogicalPresentation* mode + ) => DllImport.GetRenderLogicalPresentation(renderer, w, h, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetHaptics(Ref count) + MaybeBool ISdl.GetRenderLogicalPresentation( + RendererHandle renderer, + Ref w, + Ref h, + Ref mode + ) { - fixed (int* __dsl_count = count) + fixed (RendererLogicalPresentation* __dsl_mode = mode) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (uint*)((ISdl)this).GetHaptics(__dsl_count); + return (MaybeBool) + (byte) + ((ISdl)this).GetRenderLogicalPresentation( + renderer, + __dsl_w, + __dsl_h, + __dsl_mode + ); } } - [return: NativeTypeName("SDL_HapticID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHaptics")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetHaptics(Ref count) => DllImport.GetHaptics(count); + public static MaybeBool GetRenderLogicalPresentation( + RendererHandle renderer, + Ref w, + Ref h, + Ref mode + ) => DllImport.GetRenderLogicalPresentation(renderer, w, h, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetHint([NativeTypeName("const char *")] sbyte* name) => + byte ISdl.GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => ( - (delegate* unmanaged)( - _slots[255] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[458] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[255] = nativeContext.LoadFunction("SDL_GetHint", "SDL3") + : _slots[458] = nativeContext.LoadFunction( + "SDL_GetRenderLogicalPresentationRect", + "SDL3" + ) ) - )(name); + )(renderer, rect); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetHint([NativeTypeName("const char *")] sbyte* name) => - DllImport.GetHint(name); + public static byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => + DllImport.GetRenderLogicalPresentationRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetHint([NativeTypeName("const char *")] Ref name) + MaybeBool ISdl.GetRenderLogicalPresentationRect(RendererHandle renderer, Ref rect) { - fixed (sbyte* __dsl_name = name) + fixed (FRect* __dsl_rect = rect) { - return (sbyte*)((ISdl)this).GetHint(__dsl_name); + return (MaybeBool) + (byte)((ISdl)this).GetRenderLogicalPresentationRect(renderer, __dsl_rect); } } - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHint")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetHint([NativeTypeName("const char *")] Ref name) => - DllImport.GetHint(name); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetHintBoolean( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => - ( - (delegate* unmanaged)( - _slots[256] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[256] = nativeContext.LoadFunction("SDL_GetHintBoolean", "SDL3") - ) - )(name, default_value); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetHintBoolean( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte default_value - ) => DllImport.GetHintBoolean(name, default_value); + public static MaybeBool GetRenderLogicalPresentationRect( + RendererHandle renderer, + Ref rect + ) => DllImport.GetRenderLogicalPresentationRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetHintBoolean( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool) - (byte)((ISdl)this).GetHintBoolean(__dsl_name, (byte)default_value); - } - } + Ptr ISdl.GetRenderMetalCommandEncoder(RendererHandle renderer) => + (void*)((ISdl)this).GetRenderMetalCommandEncoderRaw(renderer); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetHintBoolean")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetHintBoolean( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool default_value - ) => DllImport.GetHintBoolean(name, default_value); + public static Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => + DllImport.GetRenderMetalCommandEncoder(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetIOProperties(IOStreamHandle context) => + void* ISdl.GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[257] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[459] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[257] = nativeContext.LoadFunction("SDL_GetIOProperties", "SDL3") + : _slots[459] = nativeContext.LoadFunction( + "SDL_GetRenderMetalCommandEncoder", + "SDL3" + ) ) - )(context); + )(renderer); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetIOProperties(IOStreamHandle context) => - DllImport.GetIOProperties(context); + public static void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => + DllImport.GetRenderMetalCommandEncoderRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - long ISdl.GetIOSize(IOStreamHandle context) => - ( - (delegate* unmanaged)( - _slots[258] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[258] = nativeContext.LoadFunction("SDL_GetIOSize", "SDL3") - ) - )(context); + Ptr ISdl.GetRenderMetalLayer(RendererHandle renderer) => + (void*)((ISdl)this).GetRenderMetalLayerRaw(renderer); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOSize")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static long GetIOSize(IOStreamHandle context) => DllImport.GetIOSize(context); + public static Ptr GetRenderMetalLayer(RendererHandle renderer) => + DllImport.GetRenderMetalLayer(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStatus ISdl.GetIOStatus(IOStreamHandle context) => + void* ISdl.GetRenderMetalLayerRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[259] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[460] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[259] = nativeContext.LoadFunction("SDL_GetIOStatus", "SDL3") + : _slots[460] = nativeContext.LoadFunction("SDL_GetRenderMetalLayer", "SDL3") ) - )(context); + )(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetIOStatus")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStatus GetIOStatus(IOStreamHandle context) => DllImport.GetIOStatus(context); + public static void* GetRenderMetalLayerRaw(RendererHandle renderer) => + DllImport.GetRenderMetalLayerRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - short ISdl.GetJoystickAxis(JoystickHandle joystick, int axis) => + byte ISdl.GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[260] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[461] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[260] = nativeContext.LoadFunction("SDL_GetJoystickAxis", "SDL3") + : _slots[461] = nativeContext.LoadFunction("SDL_GetRenderOutputSize", "SDL3") ) - )(joystick, axis); + )(renderer, w, h); - [return: NativeTypeName("Sint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxis")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static short GetJoystickAxis(JoystickHandle joystick, int axis) => - DllImport.GetJoystickAxis(joystick, axis); + public static byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => + DllImport.GetRenderOutputSize(renderer, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] short* state - ) => + MaybeBool ISdl.GetRenderOutputSize(RendererHandle renderer, Ref w, Ref h) + { + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) + { + return (MaybeBool) + (byte)((ISdl)this).GetRenderOutputSize(renderer, __dsl_w, __dsl_h); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetRenderOutputSize( + RendererHandle renderer, + Ref w, + Ref h + ) => DllImport.GetRenderOutputSize(renderer, w, h); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetRenderSafeArea(RendererHandle renderer, Rect* rect) => ( - (delegate* unmanaged)( - _slots[261] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[462] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[261] = nativeContext.LoadFunction( - "SDL_GetJoystickAxisInitialState", - "SDL3" - ) + : _slots[462] = nativeContext.LoadFunction("SDL_GetRenderSafeArea", "SDL3") ) - )(joystick, axis, state); + )(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] short* state - ) => DllImport.GetJoystickAxisInitialState(joystick, axis, state); + public static byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => + DllImport.GetRenderSafeArea(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] Ref state - ) + MaybeBool ISdl.GetRenderSafeArea(RendererHandle renderer, Ref rect) { - fixed (short* __dsl_state = state) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte)((ISdl)this).GetJoystickAxisInitialState(joystick, axis, __dsl_state); + return (MaybeBool)(byte)((ISdl)this).GetRenderSafeArea(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickAxisInitialState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetJoystickAxisInitialState( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16 *")] Ref state - ) => DllImport.GetJoystickAxisInitialState(joystick, axis, state); + public static MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) => + DllImport.GetRenderSafeArea(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => + byte ISdl.GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => ( - (delegate* unmanaged)( - _slots[262] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[463] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[262] = nativeContext.LoadFunction("SDL_GetJoystickBall", "SDL3") + : _slots[463] = nativeContext.LoadFunction("SDL_GetRenderScale", "SDL3") ) - )(joystick, ball, dx, dy); + )(renderer, scaleX, scaleY); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetJoystickBall(JoystickHandle joystick, int ball, int* dx, int* dy) => - DllImport.GetJoystickBall(joystick, ball, dx, dy); + public static byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => + DllImport.GetRenderScale(renderer, scaleX, scaleY); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetJoystickBall( - JoystickHandle joystick, - int ball, - Ref dx, - Ref dy + MaybeBool ISdl.GetRenderScale( + RendererHandle renderer, + Ref scaleX, + Ref scaleY ) { - fixed (int* __dsl_dy = dy) - fixed (int* __dsl_dx = dx) + fixed (float* __dsl_scaleY = scaleY) + fixed (float* __dsl_scaleX = scaleX) { return (MaybeBool) - (byte)((ISdl)this).GetJoystickBall(joystick, ball, __dsl_dx, __dsl_dy); + (byte)((ISdl)this).GetRenderScale(renderer, __dsl_scaleX, __dsl_scaleY); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetJoystickBall( - JoystickHandle joystick, - int ball, - Ref dx, - Ref dy - ) => DllImport.GetJoystickBall(joystick, ball, dx, dy); + public static MaybeBool GetRenderScale( + RendererHandle renderer, + Ref scaleX, + Ref scaleY + ) => DllImport.GetRenderScale(renderer, scaleX, scaleY); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetJoystickButton(JoystickHandle joystick, int button) => - (MaybeBool)(byte)((ISdl)this).GetJoystickButtonRaw(joystick, button); + Ptr ISdl.GetRenderTarget(RendererHandle renderer) => + (Texture*)((ISdl)this).GetRenderTargetRaw(renderer); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetJoystickButton(JoystickHandle joystick, int button) => - DllImport.GetJoystickButton(joystick, button); + public static Ptr GetRenderTarget(RendererHandle renderer) => + DllImport.GetRenderTarget(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetJoystickButtonRaw(JoystickHandle joystick, int button) => + Texture* ISdl.GetRenderTargetRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[263] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[464] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[263] = nativeContext.LoadFunction("SDL_GetJoystickButton", "SDL3") + : _slots[464] = nativeContext.LoadFunction("SDL_GetRenderTarget", "SDL3") ) - )(joystick, button); + )(renderer); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetJoystickButtonRaw(JoystickHandle joystick, int button) => - DllImport.GetJoystickButtonRaw(joystick, button); + public static Texture* GetRenderTargetRaw(RendererHandle renderer) => + DllImport.GetRenderTargetRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickConnectionState ISdl.GetJoystickConnectionState(JoystickHandle joystick) => + byte ISdl.GetRenderViewport(RendererHandle renderer, Rect* rect) => ( - (delegate* unmanaged)( - _slots[264] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[465] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[264] = nativeContext.LoadFunction( - "SDL_GetJoystickConnectionState", - "SDL3" - ) + : _slots[465] = nativeContext.LoadFunction("SDL_GetRenderViewport", "SDL3") ) - )(joystick); + )(renderer, rect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickConnectionState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickConnectionState GetJoystickConnectionState(JoystickHandle joystick) => - DllImport.GetJoystickConnectionState(joystick); + public static byte GetRenderViewport(RendererHandle renderer, Rect* rect) => + DllImport.GetRenderViewport(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickFirmwareVersion(JoystickHandle joystick) => - ( - (delegate* unmanaged)( - _slots[265] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[265] = nativeContext.LoadFunction( - "SDL_GetJoystickFirmwareVersion", - "SDL3" - ) - ) - )(joystick); + MaybeBool ISdl.GetRenderViewport(RendererHandle renderer, Ref rect) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)((ISdl)this).GetRenderViewport(renderer, __dsl_rect); + } + } - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFirmwareVersion")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickFirmwareVersion(JoystickHandle joystick) => - DllImport.GetJoystickFirmwareVersion(joystick); + public static MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) => + DllImport.GetRenderViewport(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickHandle ISdl.GetJoystickFromID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + byte ISdl.GetRenderVSync(RendererHandle renderer, int* vsync) => ( - (delegate* unmanaged)( - _slots[266] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[466] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[266] = nativeContext.LoadFunction("SDL_GetJoystickFromID", "SDL3") + : _slots[466] = nativeContext.LoadFunction("SDL_GetRenderVSync", "SDL3") ) - )(instance_id); + )(renderer, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickHandle GetJoystickFromID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickFromID(instance_id); + public static byte GetRenderVSync(RendererHandle renderer, int* vsync) => + DllImport.GetRenderVSync(renderer, vsync); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickHandle ISdl.GetJoystickFromPlayerIndex(int player_index) => + MaybeBool ISdl.GetRenderVSync(RendererHandle renderer, Ref vsync) + { + fixed (int* __dsl_vsync = vsync) + { + return (MaybeBool)(byte)((ISdl)this).GetRenderVSync(renderer, __dsl_vsync); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) => + DllImport.GetRenderVSync(renderer, vsync); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.GetRenderWindow(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[267] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[467] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[267] = nativeContext.LoadFunction( - "SDL_GetJoystickFromPlayerIndex", - "SDL3" - ) + : _slots[467] = nativeContext.LoadFunction("SDL_GetRenderWindow", "SDL3") ) - )(player_index); + )(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickFromPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle GetRenderWindow(RendererHandle renderer) => + DllImport.GetRenderWindow(renderer); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetRevision() => (sbyte*)((ISdl)this).GetRevisionRaw(); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickHandle GetJoystickFromPlayerIndex(int player_index) => - DllImport.GetJoystickFromPlayerIndex(player_index); + public static Ptr GetRevision() => DllImport.GetRevision(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Guid ISdl.GetJoystickGuid(JoystickHandle joystick) => + sbyte* ISdl.GetRevisionRaw() => ( - (delegate* unmanaged)( - _slots[268] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[468] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[268] = nativeContext.LoadFunction("SDL_GetJoystickGUID", "SDL3") + : _slots[468] = nativeContext.LoadFunction("SDL_GetRevision", "SDL3") ) - )(joystick); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Guid GetJoystickGuid(JoystickHandle joystick) => - DllImport.GetJoystickGuid(joystick); + public static sbyte* GetRevisionRaw() => DllImport.GetRevisionRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Guid ISdl.GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + void ISdl.GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => ( - (delegate* unmanaged)( - _slots[269] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[469] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[269] = nativeContext.LoadFunction("SDL_GetJoystickGUIDForID", "SDL3") + : _slots[469] = nativeContext.LoadFunction("SDL_GetRGB", "SDL3") ) - )(instance_id); + )(pixel, format, palette, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Guid GetJoystickGuidForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.GetJoystickGuidForID(instance_id); + public static void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => DllImport.GetRGB(pixel, format, palette, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] ushort* vendor, - [NativeTypeName("Uint16 *")] ushort* product, - [NativeTypeName("Uint16 *")] ushort* version, - [NativeTypeName("Uint16 *")] ushort* crc16 + void ISdl.GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) + { + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + ((ISdl)this).GetRGB(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void GetRGB( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => DllImport.GetRGB(pixel, format, palette, r, g, b); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a ) => ( - (delegate* unmanaged)( - _slots[270] is not null and var loadedFnPtr + (delegate* unmanaged< + uint, + PixelFormatDetails*, + Palette*, + byte*, + byte*, + byte*, + byte*, + void>)( + _slots[470] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[270] = nativeContext.LoadFunction("SDL_GetJoystickGUIDInfo", "SDL3") + : _slots[470] = nativeContext.LoadFunction("SDL_GetRGBA", "SDL3") ) - )(guid, vendor, product, version, crc16); + )(pixel, format, palette, r, g, b, a); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] ushort* vendor, - [NativeTypeName("Uint16 *")] ushort* product, - [NativeTypeName("Uint16 *")] ushort* version, - [NativeTypeName("Uint16 *")] ushort* crc16 - ) => DllImport.GetJoystickGuidInfo(guid, vendor, product, version, crc16); + public static void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => DllImport.GetRgba(pixel, format, palette, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] Ref vendor, - [NativeTypeName("Uint16 *")] Ref product, - [NativeTypeName("Uint16 *")] Ref version, - [NativeTypeName("Uint16 *")] Ref crc16 + void ISdl.GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a ) { - fixed (ushort* __dsl_crc16 = crc16) - fixed (ushort* __dsl_version = version) - fixed (ushort* __dsl_product = product) - fixed (ushort* __dsl_vendor = vendor) + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) { - ((ISdl)this).GetJoystickGuidInfo( - guid, - __dsl_vendor, - __dsl_product, - __dsl_version, - __dsl_crc16 + ((ISdl)this).GetRgba( + pixel, + __dsl_format, + __dsl_palette, + __dsl_r, + __dsl_g, + __dsl_b, + __dsl_a ); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickGUIDInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetJoystickGuidInfo( - Guid guid, - [NativeTypeName("Uint16 *")] Ref vendor, - [NativeTypeName("Uint16 *")] Ref product, - [NativeTypeName("Uint16 *")] Ref version, - [NativeTypeName("Uint16 *")] Ref crc16 - ) => DllImport.GetJoystickGuidInfo(guid, vendor, product, version, crc16); + public static void GetRgba( + [NativeTypeName("Uint32")] uint pixel, + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => DllImport.GetRgba(pixel, format, palette, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetJoystickHat(JoystickHandle joystick, int hat) => + Sandbox ISdl.GetSandbox() => ( - (delegate* unmanaged)( - _slots[271] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[471] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[271] = nativeContext.LoadFunction("SDL_GetJoystickHat", "SDL3") + : _slots[471] = nativeContext.LoadFunction("SDL_GetSandbox", "SDL3") ) - )(joystick, hat); + )(); - [return: NativeTypeName("Uint8")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickHat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetJoystickHat(JoystickHandle joystick, int hat) => - DllImport.GetJoystickHat(joystick, hat); + public static Sandbox GetSandbox() => DllImport.GetSandbox(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetJoystickID(JoystickHandle joystick) => + Scancode ISdl.GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] ushort* modstate + ) => ( - (delegate* unmanaged)( - _slots[272] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[472] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[272] = nativeContext.LoadFunction("SDL_GetJoystickID", "SDL3") + : _slots[472] = nativeContext.LoadFunction("SDL_GetScancodeFromKey", "SDL3") ) - )(joystick); - - [return: NativeTypeName("SDL_JoystickID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickID")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetJoystickID(JoystickHandle joystick) => DllImport.GetJoystickID(joystick); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoystickName(JoystickHandle joystick) => - (sbyte*)((ISdl)this).GetJoystickNameRaw(joystick); + )(key, modstate); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoystickName(JoystickHandle joystick) => - DllImport.GetJoystickName(joystick); + public static Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] ushort* modstate + ) => DllImport.GetScancodeFromKey(key, modstate); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoystickNameForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (sbyte*)((ISdl)this).GetJoystickNameForIDRaw(instance_id); + Scancode ISdl.GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] Ref modstate + ) + { + fixed (ushort* __dsl_modstate = modstate) + { + return (Scancode)((ISdl)this).GetScancodeFromKey(key, __dsl_modstate); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoystickNameForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickNameForID(instance_id); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetJoystickNameForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[274] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[274] = nativeContext.LoadFunction("SDL_GetJoystickNameForID", "SDL3") - ) - )(instance_id); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetJoystickNameForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickNameForIDRaw(instance_id); + public static Scancode GetScancodeFromKey( + [NativeTypeName("SDL_Keycode")] uint key, + [NativeTypeName("SDL_Keymod *")] Ref modstate + ) => DllImport.GetScancodeFromKey(key, modstate); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetJoystickNameRaw(JoystickHandle joystick) => + Scancode ISdl.GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[273] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[473] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[273] = nativeContext.LoadFunction("SDL_GetJoystickName", "SDL3") + : _slots[473] = nativeContext.LoadFunction("SDL_GetScancodeFromName", "SDL3") ) - )(joystick); + )(name); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetJoystickNameRaw(JoystickHandle joystick) => - DllImport.GetJoystickNameRaw(joystick); + public static Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => + DllImport.GetScancodeFromName(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoystickPath(JoystickHandle joystick) => - (sbyte*)((ISdl)this).GetJoystickPathRaw(joystick); + Scancode ISdl.GetScancodeFromName([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (Scancode)((ISdl)this).GetScancodeFromName(__dsl_name); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoystickPath(JoystickHandle joystick) => - DllImport.GetJoystickPath(joystick); + public static Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) => + DllImport.GetScancodeFromName(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoystickPathForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (sbyte*)((ISdl)this).GetJoystickPathForIDRaw(instance_id); + Ptr ISdl.GetScancodeName(Scancode scancode) => + (sbyte*)((ISdl)this).GetScancodeNameRaw(scancode); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoystickPathForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickPathForID(instance_id); + public static Ptr GetScancodeName(Scancode scancode) => + DllImport.GetScancodeName(scancode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetJoystickPathForIDRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + sbyte* ISdl.GetScancodeNameRaw(Scancode scancode) => ( - (delegate* unmanaged)( - _slots[276] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[474] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[276] = nativeContext.LoadFunction("SDL_GetJoystickPathForID", "SDL3") + : _slots[474] = nativeContext.LoadFunction("SDL_GetScancodeName", "SDL3") ) - )(instance_id); + )(scancode); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPathForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetJoystickPathForIDRaw( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickPathForIDRaw(instance_id); + public static sbyte* GetScancodeNameRaw(Scancode scancode) => + DllImport.GetScancodeNameRaw(scancode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetJoystickPathRaw(JoystickHandle joystick) => + uint ISdl.GetSemaphoreValue(SemaphoreHandle sem) => ( - (delegate* unmanaged)( - _slots[275] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[475] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[275] = nativeContext.LoadFunction("SDL_GetJoystickPath", "SDL3") + : _slots[475] = nativeContext.LoadFunction("SDL_GetSemaphoreValue", "SDL3") ) - )(joystick); + )(sem); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPath")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetJoystickPathRaw(JoystickHandle joystick) => - DllImport.GetJoystickPathRaw(joystick); + public static uint GetSemaphoreValue(SemaphoreHandle sem) => DllImport.GetSemaphoreValue(sem); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetJoystickPlayerIndex(JoystickHandle joystick) => + byte ISdl.GetSensorData(SensorHandle sensor, float* data, int num_values) => ( - (delegate* unmanaged)( - _slots[277] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[476] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[277] = nativeContext.LoadFunction("SDL_GetJoystickPlayerIndex", "SDL3") + : _slots[476] = nativeContext.LoadFunction("SDL_GetSensorData", "SDL3") ) - )(joystick); + )(sensor, data, num_values); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndex")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetJoystickPlayerIndex(JoystickHandle joystick) => - DllImport.GetJoystickPlayerIndex(joystick); + public static byte GetSensorData(SensorHandle sensor, float* data, int num_values) => + DllImport.GetSensorData(sensor, data, num_values); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetJoystickPlayerIndexForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + MaybeBool ISdl.GetSensorData(SensorHandle sensor, Ref data, int num_values) + { + fixed (float* __dsl_data = data) + { + return (MaybeBool) + (byte)((ISdl)this).GetSensorData(sensor, __dsl_data, num_values); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetSensorData( + SensorHandle sensor, + Ref data, + int num_values + ) => DllImport.GetSensorData(sensor, data, num_values); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + SensorHandle ISdl.GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[278] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[477] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[278] = nativeContext.LoadFunction( - "SDL_GetJoystickPlayerIndexForID", - "SDL3" - ) + : _slots[477] = nativeContext.LoadFunction("SDL_GetSensorFromID", "SDL3") ) )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPlayerIndexForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetJoystickPlayerIndexForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickPlayerIndexForID(instance_id); + public static SensorHandle GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => + DllImport.GetSensorFromID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => + uint ISdl.GetSensorID(SensorHandle sensor) => ( - (delegate* unmanaged)( - _slots[279] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[478] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[279] = nativeContext.LoadFunction("SDL_GetJoystickPowerInfo", "SDL3") + : _slots[478] = nativeContext.LoadFunction("SDL_GetSensorID", "SDL3") ) - )(joystick, percent); + )(sensor); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] + [return: NativeTypeName("SDL_SensorID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, int* percent) => - DllImport.GetJoystickPowerInfo(joystick, percent); + public static uint GetSensorID(SensorHandle sensor) => DllImport.GetSensorID(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) - { - fixed (int* __dsl_percent = percent) - { - return (PowerState)((ISdl)this).GetJoystickPowerInfo(joystick, __dsl_percent); - } - } + Ptr ISdl.GetSensorName(SensorHandle sensor) => + (sbyte*)((ISdl)this).GetSensorNameRaw(sensor); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickPowerInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetJoystickPowerInfo(JoystickHandle joystick, Ref percent) => - DllImport.GetJoystickPowerInfo(joystick, percent); + public static Ptr GetSensorName(SensorHandle sensor) => DllImport.GetSensorName(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickProduct(JoystickHandle joystick) => + Ptr ISdl.GetSensorNameForID([NativeTypeName("SDL_SensorID")] uint instance_id) => + (sbyte*)((ISdl)this).GetSensorNameForIDRaw(instance_id); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetSensorNameForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => DllImport.GetSensorNameForID(instance_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[280] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[480] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[280] = nativeContext.LoadFunction("SDL_GetJoystickProduct", "SDL3") + : _slots[480] = nativeContext.LoadFunction("SDL_GetSensorNameForID", "SDL3") ) - )(joystick); + )(instance_id); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProduct")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickProduct(JoystickHandle joystick) => - DllImport.GetJoystickProduct(joystick); + public static sbyte* GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => + DllImport.GetSensorNameForIDRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickProductForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + sbyte* ISdl.GetSensorNameRaw(SensorHandle sensor) => ( - (delegate* unmanaged)( - _slots[281] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[479] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[281] = nativeContext.LoadFunction( - "SDL_GetJoystickProductForID", - "SDL3" - ) + : _slots[479] = nativeContext.LoadFunction("SDL_GetSensorName", "SDL3") ) - )(instance_id); + )(sensor); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductForID")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickProductForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickProductForID(instance_id); + public static sbyte* GetSensorNameRaw(SensorHandle sensor) => + DllImport.GetSensorNameRaw(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickProductVersion(JoystickHandle joystick) => + int ISdl.GetSensorNonPortableType(SensorHandle sensor) => ( - (delegate* unmanaged)( - _slots[282] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[481] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[282] = nativeContext.LoadFunction( - "SDL_GetJoystickProductVersion", + : _slots[481] = nativeContext.LoadFunction( + "SDL_GetSensorNonPortableType", "SDL3" ) ) - )(joystick); + )(sensor); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickProductVersion(JoystickHandle joystick) => - DllImport.GetJoystickProductVersion(joystick); + public static int GetSensorNonPortableType(SensorHandle sensor) => + DllImport.GetSensorNonPortableType(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => + int ISdl.GetSensorNonPortableTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[283] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[482] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[283] = nativeContext.LoadFunction( - "SDL_GetJoystickProductVersionForID", + : _slots[482] = nativeContext.LoadFunction( + "SDL_GetSensorNonPortableTypeForID", "SDL3" ) ) )(instance_id); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProductVersionForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickProductVersionForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickProductVersionForID(instance_id); + public static int GetSensorNonPortableTypeForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => DllImport.GetSensorNonPortableTypeForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetJoystickProperties(JoystickHandle joystick) => + uint ISdl.GetSensorProperties(SensorHandle sensor) => ( - (delegate* unmanaged)( - _slots[284] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[483] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[284] = nativeContext.LoadFunction("SDL_GetJoystickProperties", "SDL3") + : _slots[483] = nativeContext.LoadFunction("SDL_GetSensorProperties", "SDL3") ) - )(joystick); + )(sensor); [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetJoystickProperties(JoystickHandle joystick) => - DllImport.GetJoystickProperties(joystick); + public static uint GetSensorProperties(SensorHandle sensor) => + DllImport.GetSensorProperties(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetJoysticks(int* count) => + uint* ISdl.GetSensors(int* count) => ( (delegate* unmanaged)( - _slots[285] is not null and var loadedFnPtr + _slots[484] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[285] = nativeContext.LoadFunction("SDL_GetJoysticks", "SDL3") + : _slots[484] = nativeContext.LoadFunction("SDL_GetSensors", "SDL3") ) )(count); - [return: NativeTypeName("SDL_JoystickID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [return: NativeTypeName("SDL_SensorID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetJoysticks(int* count) => DllImport.GetJoysticks(count); + public static uint* GetSensors(int* count) => DllImport.GetSensors(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoysticks(Ref count) + Ptr ISdl.GetSensors(Ref count) { fixed (int* __dsl_count = count) { - return (uint*)((ISdl)this).GetJoysticks(__dsl_count); + return (uint*)((ISdl)this).GetSensors(__dsl_count); } } - [return: NativeTypeName("SDL_JoystickID *")] + [return: NativeTypeName("SDL_SensorID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoysticks")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoysticks(Ref count) => DllImport.GetJoysticks(count); + public static Ptr GetSensors(Ref count) => DllImport.GetSensors(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetJoystickSerial(JoystickHandle joystick) => - (sbyte*)((ISdl)this).GetJoystickSerialRaw(joystick); + SensorType ISdl.GetSensorType(SensorHandle sensor) => + ( + (delegate* unmanaged)( + _slots[485] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[485] = nativeContext.LoadFunction("SDL_GetSensorType", "SDL3") + ) + )(sensor); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetJoystickSerial(JoystickHandle joystick) => - DllImport.GetJoystickSerial(joystick); + public static SensorType GetSensorType(SensorHandle sensor) => DllImport.GetSensorType(sensor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetJoystickSerialRaw(JoystickHandle joystick) => + SensorType ISdl.GetSensorTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[286] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[486] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[286] = nativeContext.LoadFunction("SDL_GetJoystickSerial", "SDL3") + : _slots[486] = nativeContext.LoadFunction("SDL_GetSensorTypeForID", "SDL3") ) - )(joystick); + )(instance_id); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickSerial")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetJoystickSerialRaw(JoystickHandle joystick) => - DllImport.GetJoystickSerialRaw(joystick); + public static SensorType GetSensorTypeForID( + [NativeTypeName("SDL_SensorID")] uint instance_id + ) => DllImport.GetSensorTypeForID(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickType ISdl.GetJoystickType(JoystickHandle joystick) => + int ISdl.GetSilenceValueForFormat(AudioFormat format) => ( - (delegate* unmanaged)( - _slots[287] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[487] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[287] = nativeContext.LoadFunction("SDL_GetJoystickType", "SDL3") + : _slots[487] = nativeContext.LoadFunction( + "SDL_GetSilenceValueForFormat", + "SDL3" + ) ) - )(joystick); + )(format); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickType GetJoystickType(JoystickHandle joystick) => - DllImport.GetJoystickType(joystick); + public static int GetSilenceValueForFormat(AudioFormat format) => + DllImport.GetSilenceValueForFormat(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickType ISdl.GetJoystickTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + nuint ISdl.GetSimdAlignment() => ( - (delegate* unmanaged)( - _slots[288] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[488] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[288] = nativeContext.LoadFunction("SDL_GetJoystickTypeForID", "SDL3") + : _slots[488] = nativeContext.LoadFunction("SDL_GetSIMDAlignment", "SDL3") ) - )(instance_id); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickTypeForID")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickType GetJoystickTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickTypeForID(instance_id); + public static nuint GetSimdAlignment() => DllImport.GetSimdAlignment(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickVendor(JoystickHandle joystick) => + byte ISdl.GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("Uint64 *")] ulong* length + ) => ( - (delegate* unmanaged)( - _slots[289] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[489] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[289] = nativeContext.LoadFunction("SDL_GetJoystickVendor", "SDL3") + : _slots[489] = nativeContext.LoadFunction("SDL_GetStorageFileSize", "SDL3") ) - )(joystick); + )(storage, path, length); - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendor")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickVendor(JoystickHandle joystick) => - DllImport.GetJoystickVendor(joystick); + public static byte GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("Uint64 *")] ulong* length + ) => DllImport.GetStorageFileSize(storage, path, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetJoystickVendorForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[290] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[290] = nativeContext.LoadFunction("SDL_GetJoystickVendorForID", "SDL3") - ) - )(instance_id); + MaybeBool ISdl.GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("Uint64 *")] Ref length + ) + { + fixed (ulong* __dsl_length = length) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)((ISdl)this).GetStorageFileSize(storage, __dsl_path, __dsl_length); + } + } - [return: NativeTypeName("Uint16")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetJoystickVendorForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetJoystickVendorForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetJoystickVendorForID(instance_id); + public static MaybeBool GetStorageFileSize( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("Uint64 *")] Ref length + ) => DllImport.GetStorageFileSize(storage, path, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetKeyboardFocus() => + byte ISdl.GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + PathInfo* info + ) => ( - (delegate* unmanaged)( - _slots[291] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[490] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[291] = nativeContext.LoadFunction("SDL_GetKeyboardFocus", "SDL3") + : _slots[490] = nativeContext.LoadFunction("SDL_GetStoragePathInfo", "SDL3") ) - )(); + )(storage, path, info); - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardFocus")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetKeyboardFocus() => DllImport.GetKeyboardFocus(); + public static byte GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + PathInfo* info + ) => DllImport.GetStoragePathInfo(storage, path, info); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetKeyboardNameForID([NativeTypeName("SDL_KeyboardID")] uint instance_id) => - (sbyte*)((ISdl)this).GetKeyboardNameForIDRaw(instance_id); + MaybeBool ISdl.GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref info + ) + { + fixed (PathInfo* __dsl_info = info) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte)((ISdl)this).GetStoragePathInfo(storage, __dsl_path, __dsl_info); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetKeyboardNameForID( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => DllImport.GetKeyboardNameForID(instance_id); + public static MaybeBool GetStoragePathInfo( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref info + ) => DllImport.GetStoragePathInfo(storage, path, info); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetKeyboardNameForIDRaw([NativeTypeName("SDL_KeyboardID")] uint instance_id) => + ulong ISdl.GetStorageSpaceRemaining(StorageHandle storage) => ( - (delegate* unmanaged)( - _slots[292] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[491] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[292] = nativeContext.LoadFunction("SDL_GetKeyboardNameForID", "SDL3") + : _slots[491] = nativeContext.LoadFunction( + "SDL_GetStorageSpaceRemaining", + "SDL3" + ) ) - )(instance_id); + )(storage); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardNameForID")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetKeyboardNameForIDRaw( - [NativeTypeName("SDL_KeyboardID")] uint instance_id - ) => DllImport.GetKeyboardNameForIDRaw(instance_id); + public static ulong GetStorageSpaceRemaining(StorageHandle storage) => + DllImport.GetStorageSpaceRemaining(storage); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetKeyboards(int* count) => + sbyte* ISdl.GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* default_value + ) => ( - (delegate* unmanaged)( - _slots[293] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[492] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[293] = nativeContext.LoadFunction("SDL_GetKeyboards", "SDL3") + : _slots[492] = nativeContext.LoadFunction("SDL_GetStringProperty", "SDL3") ) - )(count); + )(props, name, default_value); - [return: NativeTypeName("SDL_KeyboardID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetKeyboards(int* count) => DllImport.GetKeyboards(count); + public static sbyte* GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* default_value + ) => DllImport.GetStringProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetKeyboards(Ref count) + Ptr ISdl.GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref default_value + ) { - fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_default_value = default_value) + fixed (sbyte* __dsl_name = name) { - return (uint*)((ISdl)this).GetKeyboards(__dsl_count); + return (sbyte*)((ISdl)this).GetStringProperty(props, __dsl_name, __dsl_default_value); } } - [return: NativeTypeName("SDL_KeyboardID *")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboards")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetKeyboards(Ref count) => DllImport.GetKeyboards(count); + public static Ptr GetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref default_value + ) => DllImport.GetStringProperty(props, name, default_value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - bool* ISdl.GetKeyboardState(int* numkeys) => + byte ISdl.GetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8 *")] byte* alpha) => ( - (delegate* unmanaged)( - _slots[294] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[493] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[294] = nativeContext.LoadFunction("SDL_GetKeyboardState", "SDL3") + : _slots[493] = nativeContext.LoadFunction("SDL_GetSurfaceAlphaMod", "SDL3") ) - )(numkeys); + )(surface, alpha); - [return: NativeTypeName("const bool *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static bool* GetKeyboardState(int* numkeys) => DllImport.GetKeyboardState(numkeys); + public static byte GetSurfaceAlphaMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* alpha + ) => DllImport.GetSurfaceAlphaMod(surface, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetKeyboardState(Ref numkeys) + MaybeBool ISdl.GetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref alpha + ) { - fixed (int* __dsl_numkeys = numkeys) + fixed (byte* __dsl_alpha = alpha) + fixed (Surface* __dsl_surface = surface) { - return (bool*)((ISdl)this).GetKeyboardState(__dsl_numkeys); + return (MaybeBool) + (byte)((ISdl)this).GetSurfaceAlphaMod(__dsl_surface, __dsl_alpha); } } - [return: NativeTypeName("const bool *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyboardState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetKeyboardState(Ref numkeys) => - DllImport.GetKeyboardState(numkeys); + public static MaybeBool GetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref alpha + ) => DllImport.GetSurfaceAlphaMod(surface, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => + byte ISdl.GetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => ( - (delegate* unmanaged)( - _slots[295] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[494] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[295] = nativeContext.LoadFunction("SDL_GetKeyFromName", "SDL3") + : _slots[494] = nativeContext.LoadFunction("SDL_GetSurfaceBlendMode", "SDL3") ) - )(name); + )(surface, blendMode); - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetKeyFromName([NativeTypeName("const char *")] sbyte* name) => - DllImport.GetKeyFromName(name); + public static byte GetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => DllImport.GetSurfaceBlendMode(surface, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetKeyFromName([NativeTypeName("const char *")] Ref name) + MaybeBool ISdl.GetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) { - fixed (sbyte* __dsl_name = name) + fixed (BlendMode* __dsl_blendMode = blendMode) + fixed (Surface* __dsl_surface = surface) { - return (uint)((ISdl)this).GetKeyFromName(__dsl_name); + return (MaybeBool) + (byte)((ISdl)this).GetSurfaceBlendMode(__dsl_surface, __dsl_blendMode); } } - [return: NativeTypeName("SDL_Keycode")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetKeyFromName([NativeTypeName("const char *")] Ref name) => - DllImport.GetKeyFromName(name); + public static MaybeBool GetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => DllImport.GetSurfaceBlendMode(surface, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] byte key_event - ) => + byte ISdl.GetSurfaceClipRect(Surface* surface, Rect* rect) => ( - (delegate* unmanaged)( - _slots[296] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[495] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[296] = nativeContext.LoadFunction("SDL_GetKeyFromScancode", "SDL3") + : _slots[495] = nativeContext.LoadFunction("SDL_GetSurfaceClipRect", "SDL3") ) - )(scancode, modstate, key_event); + )(surface, rect); - [return: NativeTypeName("SDL_Keycode")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] byte key_event - ) => DllImport.GetKeyFromScancode(scancode, modstate, key_event); + public static byte GetSurfaceClipRect(Surface* surface, Rect* rect) => + DllImport.GetSurfaceClipRect(surface, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] MaybeBool key_event - ) => (uint)((ISdl)this).GetKeyFromScancode(scancode, modstate, (byte)key_event); + MaybeBool ISdl.GetSurfaceClipRect(Ref surface, Ref rect) + { + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).GetSurfaceClipRect(__dsl_surface, __dsl_rect); + } + } - [return: NativeTypeName("SDL_Keycode")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyFromScancode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetKeyFromScancode( - Scancode scancode, - [NativeTypeName("SDL_Keymod")] ushort modstate, - [NativeTypeName("bool")] MaybeBool key_event - ) => DllImport.GetKeyFromScancode(scancode, modstate, key_event); + public static MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) => + DllImport.GetSurfaceClipRect(surface, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => - (sbyte*)((ISdl)this).GetKeyNameRaw(key); + byte ISdl.GetSurfaceColorKey(Surface* surface, [NativeTypeName("Uint32 *")] uint* key) => + ( + (delegate* unmanaged)( + _slots[496] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[496] = nativeContext.LoadFunction("SDL_GetSurfaceColorKey", "SDL3") + ) + )(surface, key); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetKeyName([NativeTypeName("SDL_Keycode")] uint key) => - DllImport.GetKeyName(key); + public static byte GetSurfaceColorKey( + Surface* surface, + [NativeTypeName("Uint32 *")] uint* key + ) => DllImport.GetSurfaceColorKey(surface, key); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => - ( - (delegate* unmanaged)( - _slots[297] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[297] = nativeContext.LoadFunction("SDL_GetKeyName", "SDL3") - ) - )(key); + MaybeBool ISdl.GetSurfaceColorKey( + Ref surface, + [NativeTypeName("Uint32 *")] Ref key + ) + { + fixed (uint* __dsl_key = key) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)((ISdl)this).GetSurfaceColorKey(__dsl_surface, __dsl_key); + } + } - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetKeyName")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetKeyNameRaw([NativeTypeName("SDL_Keycode")] uint key) => - DllImport.GetKeyNameRaw(key); + public static MaybeBool GetSurfaceColorKey( + Ref surface, + [NativeTypeName("Uint32 *")] Ref key + ) => DllImport.GetSurfaceColorKey(surface, key); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, - void** userdata + byte ISdl.GetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b ) => ( - (delegate* unmanaged)( - _slots[298] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[497] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[298] = nativeContext.LoadFunction("SDL_GetLogOutputFunction", "SDL3") + : _slots[497] = nativeContext.LoadFunction("SDL_GetSurfaceColorMod", "SDL3") ) - )(callback, userdata); + )(surface, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] LogOutputFunction* callback, - void** userdata - ) => DllImport.GetLogOutputFunction(callback, userdata); + public static byte GetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => DllImport.GetSurfaceColorMod(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, - Ref2D userdata + MaybeBool ISdl.GetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b ) { - fixed (void** __dsl_userdata = userdata) - fixed (LogOutputFunction* __dsl_callback = callback) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) { - ((ISdl)this).GetLogOutputFunction(__dsl_callback, __dsl_userdata); + return (MaybeBool) + (byte)((ISdl)this).GetSurfaceColorMod(__dsl_surface, __dsl_r, __dsl_g, __dsl_b); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction *")] Ref callback, - Ref2D userdata - ) => DllImport.GetLogOutputFunction(callback, userdata); + public static MaybeBool GetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => DllImport.GetSurfaceColorMod(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - LogPriority ISdl.GetLogPriority(int category) => + Colorspace ISdl.GetSurfaceColorspace(Surface* surface) => ( - (delegate* unmanaged)( - _slots[299] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[498] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[299] = nativeContext.LoadFunction("SDL_GetLogPriority", "SDL3") + : _slots[498] = nativeContext.LoadFunction("SDL_GetSurfaceColorspace", "SDL3") ) - )(category); + )(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetLogPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static LogPriority GetLogPriority(int category) => DllImport.GetLogPriority(category); + public static Colorspace GetSurfaceColorspace(Surface* surface) => + DllImport.GetSurfaceColorspace(surface); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Colorspace ISdl.GetSurfaceColorspace(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Colorspace)((ISdl)this).GetSurfaceColorspace(__dsl_surface); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Colorspace GetSurfaceColorspace(Ref surface) => + DllImport.GetSurfaceColorspace(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetMasksForPixelFormat( - PixelFormat format, - int* bpp, - [NativeTypeName("Uint32 *")] uint* Rmask, - [NativeTypeName("Uint32 *")] uint* Gmask, - [NativeTypeName("Uint32 *")] uint* Bmask, - [NativeTypeName("Uint32 *")] uint* Amask - ) => + Surface** ISdl.GetSurfaceImages(Surface* surface, int* count) => ( - (delegate* unmanaged)( - _slots[300] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[499] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[300] = nativeContext.LoadFunction("SDL_GetMasksForPixelFormat", "SDL3") + : _slots[499] = nativeContext.LoadFunction("SDL_GetSurfaceImages", "SDL3") ) - )(format, bpp, Rmask, Gmask, Bmask, Amask); + )(surface, count); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetMasksForPixelFormat( - PixelFormat format, - int* bpp, - [NativeTypeName("Uint32 *")] uint* Rmask, - [NativeTypeName("Uint32 *")] uint* Gmask, - [NativeTypeName("Uint32 *")] uint* Bmask, - [NativeTypeName("Uint32 *")] uint* Amask - ) => DllImport.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); + public static Surface** GetSurfaceImages(Surface* surface, int* count) => + DllImport.GetSurfaceImages(surface, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetMasksForPixelFormat( - PixelFormat format, - Ref bpp, - [NativeTypeName("Uint32 *")] Ref Rmask, - [NativeTypeName("Uint32 *")] Ref Gmask, - [NativeTypeName("Uint32 *")] Ref Bmask, - [NativeTypeName("Uint32 *")] Ref Amask - ) + Ptr2D ISdl.GetSurfaceImages(Ref surface, Ref count) { - fixed (uint* __dsl_Amask = Amask) - fixed (uint* __dsl_Bmask = Bmask) - fixed (uint* __dsl_Gmask = Gmask) - fixed (uint* __dsl_Rmask = Rmask) - fixed (int* __dsl_bpp = bpp) + fixed (int* __dsl_count = count) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte) - ((ISdl)this).GetMasksForPixelFormat( - format, - __dsl_bpp, - __dsl_Rmask, - __dsl_Gmask, - __dsl_Bmask, - __dsl_Amask - ); + return (Surface**)((ISdl)this).GetSurfaceImages(__dsl_surface, __dsl_count); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMasksForPixelFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetMasksForPixelFormat( - PixelFormat format, - Ref bpp, - [NativeTypeName("Uint32 *")] Ref Rmask, - [NativeTypeName("Uint32 *")] Ref Gmask, - [NativeTypeName("Uint32 *")] Ref Bmask, - [NativeTypeName("Uint32 *")] Ref Amask - ) => DllImport.GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask); + public static Ptr2D GetSurfaceImages(Ref surface, Ref count) => + DllImport.GetSurfaceImages(surface, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetMaxHapticEffects(HapticHandle haptic) => + Palette* ISdl.GetSurfacePalette(Surface* surface) => ( - (delegate* unmanaged)( - _slots[301] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[500] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[301] = nativeContext.LoadFunction("SDL_GetMaxHapticEffects", "SDL3") + : _slots[500] = nativeContext.LoadFunction("SDL_GetSurfacePalette", "SDL3") ) - )(haptic); + )(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetMaxHapticEffects(HapticHandle haptic) => - DllImport.GetMaxHapticEffects(haptic); + public static Palette* GetSurfacePalette(Surface* surface) => + DllImport.GetSurfacePalette(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetMaxHapticEffectsPlaying(HapticHandle haptic) => - ( - (delegate* unmanaged)( - _slots[302] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[302] = nativeContext.LoadFunction( - "SDL_GetMaxHapticEffectsPlaying", - "SDL3" - ) - ) - )(haptic); + Ptr ISdl.GetSurfacePalette(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (Palette*)((ISdl)this).GetSurfacePalette(__dsl_surface); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetMaxHapticEffectsPlaying")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetMaxHapticEffectsPlaying(HapticHandle haptic) => - DllImport.GetMaxHapticEffectsPlaying(haptic); + public static Ptr GetSurfacePalette(Ref surface) => + DllImport.GetSurfacePalette(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetMice(int* count) => + uint ISdl.GetSurfaceProperties(Surface* surface) => ( - (delegate* unmanaged)( - _slots[303] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[501] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[303] = nativeContext.LoadFunction("SDL_GetMice", "SDL3") + : _slots[501] = nativeContext.LoadFunction("SDL_GetSurfaceProperties", "SDL3") ) - )(count); + )(surface); - [return: NativeTypeName("SDL_MouseID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetMice(int* count) => DllImport.GetMice(count); + public static uint GetSurfaceProperties(Surface* surface) => + DllImport.GetSurfaceProperties(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetMice(Ref count) + uint ISdl.GetSurfaceProperties(Ref surface) { - fixed (int* __dsl_count = count) + fixed (Surface* __dsl_surface = surface) { - return (uint*)((ISdl)this).GetMice(__dsl_count); + return (uint)((ISdl)this).GetSurfaceProperties(__dsl_surface); } } - [return: NativeTypeName("SDL_MouseID *")] + [return: NativeTypeName("SDL_PropertiesID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMice")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetMice(Ref count) => DllImport.GetMice(count); + public static uint GetSurfaceProperties(Ref surface) => + DllImport.GetSurfaceProperties(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ushort ISdl.GetModState() => + int ISdl.GetSystemRAM() => ( - (delegate* unmanaged)( - _slots[304] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[502] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[304] = nativeContext.LoadFunction("SDL_GetModState", "SDL3") + : _slots[502] = nativeContext.LoadFunction("SDL_GetSystemRAM", "SDL3") ) )(); - [return: NativeTypeName("SDL_Keymod")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetModState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ushort GetModState() => DllImport.GetModState(); + public static int GetSystemRAM() => DllImport.GetSystemRAM(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetMouseFocus() => + SystemTheme ISdl.GetSystemTheme() => ( - (delegate* unmanaged)( - _slots[305] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[503] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[305] = nativeContext.LoadFunction("SDL_GetMouseFocus", "SDL3") + : _slots[503] = nativeContext.LoadFunction("SDL_GetSystemTheme", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseFocus")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetMouseFocus() => DllImport.GetMouseFocus(); + public static SystemTheme GetSystemTheme() => DllImport.GetSystemTheme(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => - (sbyte*)((ISdl)this).GetMouseNameForIDRaw(instance_id); + byte ISdl.GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => + ( + (delegate* unmanaged)( + _slots[504] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[504] = nativeContext.LoadFunction("SDL_GetTextInputArea", "SDL3") + ) + )(window, rect, cursor); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetMouseNameForID([NativeTypeName("SDL_MouseID")] uint instance_id) => - DllImport.GetMouseNameForID(instance_id); + public static byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => + DllImport.GetTextInputArea(window, rect, cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[306] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[306] = nativeContext.LoadFunction("SDL_GetMouseNameForID", "SDL3") - ) - )(instance_id); + MaybeBool ISdl.GetTextInputArea(WindowHandle window, Ref rect, Ref cursor) + { + fixed (int* __dsl_cursor = cursor) + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool) + (byte)((ISdl)this).GetTextInputArea(window, __dsl_rect, __dsl_cursor); + } + } - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseNameForID")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetMouseNameForIDRaw([NativeTypeName("SDL_MouseID")] uint instance_id) => - DllImport.GetMouseNameForIDRaw(instance_id); + public static MaybeBool GetTextInputArea( + WindowHandle window, + Ref rect, + Ref cursor + ) => DllImport.GetTextInputArea(window, rect, cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetMouseState(float* x, float* y) => + byte ISdl.GetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8 *")] byte* alpha) => ( - (delegate* unmanaged)( - _slots[307] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[505] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[307] = nativeContext.LoadFunction("SDL_GetMouseState", "SDL3") + : _slots[505] = nativeContext.LoadFunction("SDL_GetTextureAlphaMod", "SDL3") ) - )(x, y); + )(texture, alpha); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetMouseState(float* x, float* y) => DllImport.GetMouseState(x, y); + public static byte GetTextureAlphaMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* alpha + ) => DllImport.GetTextureAlphaMod(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetMouseState(Ref x, Ref y) + MaybeBool ISdl.GetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref alpha + ) { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) + fixed (byte* __dsl_alpha = alpha) + fixed (Texture* __dsl_texture = texture) { - return (uint)((ISdl)this).GetMouseState(__dsl_x, __dsl_y); + return (MaybeBool) + (byte)((ISdl)this).GetTextureAlphaMod(__dsl_texture, __dsl_alpha); } } - [return: NativeTypeName("SDL_MouseButtonFlags")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetMouseState(Ref x, Ref y) => DllImport.GetMouseState(x, y); + public static MaybeBool GetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref alpha + ) => DllImport.GetTextureAlphaMod(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayOrientation ISdl.GetNaturalDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => + byte ISdl.GetTextureAlphaModFloat(Texture* texture, float* alpha) => ( - (delegate* unmanaged)( - _slots[308] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[506] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[308] = nativeContext.LoadFunction( - "SDL_GetNaturalDisplayOrientation", + : _slots[506] = nativeContext.LoadFunction( + "SDL_GetTextureAlphaModFloat", "SDL3" ) ) - )(displayID); + )(texture, alpha); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNaturalDisplayOrientation")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayOrientation GetNaturalDisplayOrientation( - [NativeTypeName("SDL_DisplayID")] uint displayID - ) => DllImport.GetNaturalDisplayOrientation(displayID); + public static byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => + DllImport.GetTextureAlphaModFloat(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumAudioDrivers() => - ( - (delegate* unmanaged)( - _slots[309] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[309] = nativeContext.LoadFunction("SDL_GetNumAudioDrivers", "SDL3") - ) - )(); + MaybeBool ISdl.GetTextureAlphaModFloat(Ref texture, Ref alpha) + { + fixed (float* __dsl_alpha = alpha) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)((ISdl)this).GetTextureAlphaModFloat(__dsl_texture, __dsl_alpha); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumAudioDrivers")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumAudioDrivers() => DllImport.GetNumAudioDrivers(); + public static MaybeBool GetTextureAlphaModFloat(Ref texture, Ref alpha) => + DllImport.GetTextureAlphaModFloat(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - long ISdl.GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long default_value + byte ISdl.GetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode ) => ( - (delegate* unmanaged)( - _slots[310] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[507] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[310] = nativeContext.LoadFunction("SDL_GetNumberProperty", "SDL3") + : _slots[507] = nativeContext.LoadFunction("SDL_GetTextureBlendMode", "SDL3") ) - )(props, name, default_value); + )(texture, blendMode); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long default_value - ) => DllImport.GetNumberProperty(props, name, default_value); + public static byte GetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + ) => DllImport.GetTextureBlendMode(texture, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - long ISdl.GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long default_value + MaybeBool ISdl.GetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode ) { - fixed (sbyte* __dsl_name = name) + fixed (BlendMode* __dsl_blendMode = blendMode) + fixed (Texture* __dsl_texture = texture) { - return (long)((ISdl)this).GetNumberProperty(props, __dsl_name, default_value); + return (MaybeBool) + (byte)((ISdl)this).GetTextureBlendMode(__dsl_texture, __dsl_blendMode); } } - [return: NativeTypeName("Sint64")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static long GetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long default_value - ) => DllImport.GetNumberProperty(props, name, default_value); + public static MaybeBool GetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode *")] Ref blendMode + ) => DllImport.GetTextureBlendMode(texture, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumCameraDrivers() => + byte ISdl.GetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => ( - (delegate* unmanaged)( - _slots[311] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[508] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[311] = nativeContext.LoadFunction("SDL_GetNumCameraDrivers", "SDL3") + : _slots[508] = nativeContext.LoadFunction("SDL_GetTextureColorMod", "SDL3") ) - )(); + )(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumCameraDrivers")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumCameraDrivers() => DllImport.GetNumCameraDrivers(); + public static byte GetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b + ) => DllImport.GetTextureColorMod(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => + MaybeBool ISdl.GetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) + { + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)((ISdl)this).GetTextureColorMod(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b + ) => DllImport.GetTextureColorMod(texture, r, g, b); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => ( - (delegate* unmanaged)( - _slots[312] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[509] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[312] = nativeContext.LoadFunction( - "SDL_GetNumGamepadTouchpadFingers", + : _slots[509] = nativeContext.LoadFunction( + "SDL_GetTextureColorModFloat", "SDL3" ) ) - )(gamepad, touchpad); + )(texture, r, g, b); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpadFingers")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumGamepadTouchpadFingers(GamepadHandle gamepad, int touchpad) => - DllImport.GetNumGamepadTouchpadFingers(gamepad, touchpad); + public static byte GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => + DllImport.GetTextureColorModFloat(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumGamepadTouchpads(GamepadHandle gamepad) => + MaybeBool ISdl.GetTextureColorModFloat( + Ref texture, + Ref r, + Ref g, + Ref b + ) + { + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte) + ((ISdl)this).GetTextureColorModFloat(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetTextureColorModFloat( + Ref texture, + Ref r, + Ref g, + Ref b + ) => DllImport.GetTextureColorModFloat(texture, r, g, b); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.GetTextureProperties(Texture* texture) => ( - (delegate* unmanaged)( - _slots[313] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[510] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[313] = nativeContext.LoadFunction("SDL_GetNumGamepadTouchpads", "SDL3") + : _slots[510] = nativeContext.LoadFunction("SDL_GetTextureProperties", "SDL3") ) - )(gamepad); + )(texture); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumGamepadTouchpads")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumGamepadTouchpads(GamepadHandle gamepad) => - DllImport.GetNumGamepadTouchpads(gamepad); + public static uint GetTextureProperties(Texture* texture) => + DllImport.GetTextureProperties(texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumHapticAxes(HapticHandle haptic) => + uint ISdl.GetTextureProperties(Ref texture) + { + fixed (Texture* __dsl_texture = texture) + { + return (uint)((ISdl)this).GetTextureProperties(__dsl_texture); + } + } + + [return: NativeTypeName("SDL_PropertiesID")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint GetTextureProperties(Ref texture) => + DllImport.GetTextureProperties(texture); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => ( - (delegate* unmanaged)( - _slots[314] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[511] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[314] = nativeContext.LoadFunction("SDL_GetNumHapticAxes", "SDL3") + : _slots[511] = nativeContext.LoadFunction("SDL_GetTextureScaleMode", "SDL3") ) - )(haptic); + )(texture, scaleMode); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumHapticAxes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumHapticAxes(HapticHandle haptic) => DllImport.GetNumHapticAxes(haptic); + public static byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => + DllImport.GetTextureScaleMode(texture, scaleMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumJoystickAxes(JoystickHandle joystick) => + MaybeBool ISdl.GetTextureScaleMode(Ref texture, Ref scaleMode) + { + fixed (ScaleMode* __dsl_scaleMode = scaleMode) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)((ISdl)this).GetTextureScaleMode(__dsl_texture, __dsl_scaleMode); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GetTextureScaleMode( + Ref texture, + Ref scaleMode + ) => DllImport.GetTextureScaleMode(texture, scaleMode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GetTextureSize(Texture* texture, float* w, float* h) => ( - (delegate* unmanaged)( - _slots[315] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[512] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[315] = nativeContext.LoadFunction("SDL_GetNumJoystickAxes", "SDL3") + : _slots[512] = nativeContext.LoadFunction("SDL_GetTextureSize", "SDL3") ) - )(joystick); + )(texture, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickAxes")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumJoystickAxes(JoystickHandle joystick) => - DllImport.GetNumJoystickAxes(joystick); + public static byte GetTextureSize(Texture* texture, float* w, float* h) => + DllImport.GetTextureSize(texture, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumJoystickBalls(JoystickHandle joystick) => - ( - (delegate* unmanaged)( - _slots[316] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[316] = nativeContext.LoadFunction("SDL_GetNumJoystickBalls", "SDL3") - ) - )(joystick); + MaybeBool ISdl.GetTextureSize(Ref texture, Ref w, Ref h) + { + fixed (float* __dsl_h = h) + fixed (float* __dsl_w = w) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)((ISdl)this).GetTextureSize(__dsl_texture, __dsl_w, __dsl_h); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickBalls")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumJoystickBalls(JoystickHandle joystick) => - DllImport.GetNumJoystickBalls(joystick); + public static MaybeBool GetTextureSize( + Ref texture, + Ref w, + Ref h + ) => DllImport.GetTextureSize(texture, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumJoystickButtons(JoystickHandle joystick) => + ulong ISdl.GetThreadID(ThreadHandle thread) => ( - (delegate* unmanaged)( - _slots[317] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[513] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[317] = nativeContext.LoadFunction("SDL_GetNumJoystickButtons", "SDL3") + : _slots[513] = nativeContext.LoadFunction("SDL_GetThreadID", "SDL3") ) - )(joystick); + )(thread); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickButtons")] + [return: NativeTypeName("SDL_ThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumJoystickButtons(JoystickHandle joystick) => - DllImport.GetNumJoystickButtons(joystick); + public static ulong GetThreadID(ThreadHandle thread) => DllImport.GetThreadID(thread); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumJoystickHats(JoystickHandle joystick) => - ( - (delegate* unmanaged)( - _slots[318] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[318] = nativeContext.LoadFunction("SDL_GetNumJoystickHats", "SDL3") - ) - )(joystick); + Ptr ISdl.GetThreadName(ThreadHandle thread) => + (sbyte*)((ISdl)this).GetThreadNameRaw(thread); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumJoystickHats")] + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumJoystickHats(JoystickHandle joystick) => - DllImport.GetNumJoystickHats(joystick); + public static Ptr GetThreadName(ThreadHandle thread) => DllImport.GetThreadName(thread); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumLogicalCPUCores() => + sbyte* ISdl.GetThreadNameRaw(ThreadHandle thread) => ( - (delegate* unmanaged)( - _slots[319] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[514] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[319] = nativeContext.LoadFunction("SDL_GetNumLogicalCPUCores", "SDL3") + : _slots[514] = nativeContext.LoadFunction("SDL_GetThreadName", "SDL3") ) - )(); + )(thread); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumLogicalCPUCores")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumLogicalCPUCores() => DllImport.GetNumLogicalCPUCores(); + public static sbyte* GetThreadNameRaw(ThreadHandle thread) => + DllImport.GetThreadNameRaw(thread); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumRenderDrivers() => + ulong ISdl.GetTicks() => ( - (delegate* unmanaged)( - _slots[320] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[515] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[320] = nativeContext.LoadFunction("SDL_GetNumRenderDrivers", "SDL3") + : _slots[515] = nativeContext.LoadFunction("SDL_GetTicks", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumRenderDrivers")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumRenderDrivers() => DllImport.GetNumRenderDrivers(); + public static ulong GetTicks() => DllImport.GetTicks(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetNumVideoDrivers() => + ulong ISdl.GetTicksNS() => ( - (delegate* unmanaged)( - _slots[321] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[516] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[321] = nativeContext.LoadFunction("SDL_GetNumVideoDrivers", "SDL3") + : _slots[516] = nativeContext.LoadFunction("SDL_GetTicksNS", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetNumVideoDrivers")] + [return: NativeTypeName("Uint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetNumVideoDrivers() => DllImport.GetNumVideoDrivers(); + public static ulong GetTicksNS() => DllImport.GetTicksNS(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => + void* ISdl.GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => ( - (delegate* unmanaged)( - _slots[322] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[517] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[322] = nativeContext.LoadFunction("SDL_GetPathInfo", "SDL3") + : _slots[517] = nativeContext.LoadFunction("SDL_GetTLS", "SDL3") ) - )(path, info); + )(id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetPathInfo([NativeTypeName("const char *")] sbyte* path, PathInfo* info) => - DllImport.GetPathInfo(path, info); + public static void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => + DllImport.GetTLS(id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetPathInfo( - [NativeTypeName("const char *")] Ref path, - Ref info - ) + Ptr ISdl.GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) { - fixed (PathInfo* __dsl_info = info) - fixed (sbyte* __dsl_path = path) + fixed (AtomicInt* __dsl_id = id) { - return (MaybeBool)(byte)((ISdl)this).GetPathInfo(__dsl_path, __dsl_info); + return (void*)((ISdl)this).GetTLS(__dsl_id); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetPathInfo( - [NativeTypeName("const char *")] Ref path, - Ref info - ) => DllImport.GetPathInfo(path, info); + public static Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) => + DllImport.GetTLS(id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetPerformanceCounter() => + Ptr ISdl.GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => + (sbyte*)((ISdl)this).GetTouchDeviceNameRaw(touchID); + + [return: NativeTypeName("const char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => + DllImport.GetTouchDeviceName(touchID); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => ( - (delegate* unmanaged)( - _slots[323] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[518] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[323] = nativeContext.LoadFunction("SDL_GetPerformanceCounter", "SDL3") + : _slots[518] = nativeContext.LoadFunction("SDL_GetTouchDeviceName", "SDL3") ) - )(); + )(touchID); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceCounter")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetPerformanceCounter() => DllImport.GetPerformanceCounter(); + public static sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => + DllImport.GetTouchDeviceNameRaw(touchID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetPerformanceFrequency() => + ulong* ISdl.GetTouchDevices(int* count) => ( - (delegate* unmanaged)( - _slots[324] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[519] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[324] = nativeContext.LoadFunction( - "SDL_GetPerformanceFrequency", - "SDL3" - ) + : _slots[519] = nativeContext.LoadFunction("SDL_GetTouchDevices", "SDL3") ) - )(); + )(count); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPerformanceFrequency")] + [return: NativeTypeName("SDL_TouchID *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetPerformanceFrequency() => DllImport.GetPerformanceFrequency(); + public static ulong* GetTouchDevices(int* count) => DllImport.GetTouchDevices(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPixelFormatDetails(PixelFormat format) => - (PixelFormatDetails*)((ISdl)this).GetPixelFormatDetailsRaw(format); + Ptr ISdl.GetTouchDevices(Ref count) + { + fixed (int* __dsl_count = count) + { + return (ulong*)((ISdl)this).GetTouchDevices(__dsl_count); + } + } - [return: NativeTypeName("const SDL_PixelFormatDetails *")] + [return: NativeTypeName("SDL_TouchID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPixelFormatDetails(PixelFormat format) => - DllImport.GetPixelFormatDetails(format); + public static Ptr GetTouchDevices(Ref count) => DllImport.GetTouchDevices(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PixelFormatDetails* ISdl.GetPixelFormatDetailsRaw(PixelFormat format) => + TouchDeviceType ISdl.GetTouchDeviceType([NativeTypeName("SDL_TouchID")] ulong touchID) => ( - (delegate* unmanaged)( - _slots[325] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[520] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[325] = nativeContext.LoadFunction("SDL_GetPixelFormatDetails", "SDL3") + : _slots[520] = nativeContext.LoadFunction("SDL_GetTouchDeviceType", "SDL3") ) - )(format); + )(touchID); - [return: NativeTypeName("const SDL_PixelFormatDetails *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatDetails")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PixelFormatDetails* GetPixelFormatDetailsRaw(PixelFormat format) => - DllImport.GetPixelFormatDetailsRaw(format); + public static TouchDeviceType GetTouchDeviceType( + [NativeTypeName("SDL_TouchID")] ulong touchID + ) => DllImport.GetTouchDeviceType(touchID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PixelFormat ISdl.GetPixelFormatForMasks( - int bpp, - [NativeTypeName("Uint32")] uint Rmask, - [NativeTypeName("Uint32")] uint Gmask, - [NativeTypeName("Uint32")] uint Bmask, - [NativeTypeName("Uint32")] uint Amask - ) => + Finger** ISdl.GetTouchFingers([NativeTypeName("SDL_TouchID")] ulong touchID, int* count) => ( - (delegate* unmanaged)( - _slots[326] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[521] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[326] = nativeContext.LoadFunction("SDL_GetPixelFormatForMasks", "SDL3") + : _slots[521] = nativeContext.LoadFunction("SDL_GetTouchFingers", "SDL3") ) - )(bpp, Rmask, Gmask, Bmask, Amask); + )(touchID, count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatForMasks")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PixelFormat GetPixelFormatForMasks( - int bpp, - [NativeTypeName("Uint32")] uint Rmask, - [NativeTypeName("Uint32")] uint Gmask, - [NativeTypeName("Uint32")] uint Bmask, - [NativeTypeName("Uint32")] uint Amask - ) => DllImport.GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask); + public static Finger** GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + int* count + ) => DllImport.GetTouchFingers(touchID, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPixelFormatName(PixelFormat format) => - (sbyte*)((ISdl)this).GetPixelFormatNameRaw(format); + Ptr2D ISdl.GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + Ref count + ) + { + fixed (int* __dsl_count = count) + { + return (Finger**)((ISdl)this).GetTouchFingers(touchID, __dsl_count); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPixelFormatName(PixelFormat format) => - DllImport.GetPixelFormatName(format); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetPixelFormatNameRaw(PixelFormat format) => - ( - (delegate* unmanaged)( - _slots[327] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[327] = nativeContext.LoadFunction("SDL_GetPixelFormatName", "SDL3") - ) - )(format); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPixelFormatName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetPixelFormatNameRaw(PixelFormat format) => - DllImport.GetPixelFormatNameRaw(format); + public static Ptr2D GetTouchFingers( + [NativeTypeName("SDL_TouchID")] ulong touchID, + Ref count + ) => DllImport.GetTouchFingers(touchID, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPlatform() => (sbyte*)((ISdl)this).GetPlatformRaw(); + Ptr ISdl.GetUserFolder(Folder folder) => (sbyte*)((ISdl)this).GetUserFolderRaw(folder); [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPlatform() => DllImport.GetPlatform(); + public static Ptr GetUserFolder(Folder folder) => DllImport.GetUserFolder(folder); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetPlatformRaw() => + sbyte* ISdl.GetUserFolderRaw(Folder folder) => ( - (delegate* unmanaged)( - _slots[328] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[522] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[328] = nativeContext.LoadFunction("SDL_GetPlatform", "SDL3") + : _slots[522] = nativeContext.LoadFunction("SDL_GetUserFolder", "SDL3") ) - )(); + )(folder); [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPlatform")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetPlatformRaw() => DllImport.GetPlatformRaw(); + public static sbyte* GetUserFolderRaw(Folder folder) => DllImport.GetUserFolderRaw(folder); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* default_value - ) => + int ISdl.GetVersion() => ( - (delegate* unmanaged)( - _slots[329] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[523] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[329] = nativeContext.LoadFunction("SDL_GetPointerProperty", "SDL3") + : _slots[523] = nativeContext.LoadFunction("SDL_GetVersion", "SDL3") ) - )(props, name, default_value); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* default_value - ) => DllImport.GetPointerProperty(props, name, default_value); + public static int GetVersion() => DllImport.GetVersion(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref default_value - ) - { - fixed (void* __dsl_default_value = default_value) - fixed (sbyte* __dsl_name = name) - { - return (void*)((ISdl)this).GetPointerProperty(props, __dsl_name, __dsl_default_value); - } - } + Ptr ISdl.GetVideoDriver(int index) => (sbyte*)((ISdl)this).GetVideoDriverRaw(index); + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref default_value - ) => DllImport.GetPointerProperty(props, name, default_value); + public static Ptr GetVideoDriver(int index) => DllImport.GetVideoDriver(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetPowerInfo(int* seconds, int* percent) => + sbyte* ISdl.GetVideoDriverRaw(int index) => ( - (delegate* unmanaged)( - _slots[330] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[524] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[330] = nativeContext.LoadFunction("SDL_GetPowerInfo", "SDL3") + : _slots[524] = nativeContext.LoadFunction("SDL_GetVideoDriver", "SDL3") ) - )(seconds, percent); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetPowerInfo(int* seconds, int* percent) => - DllImport.GetPowerInfo(seconds, percent); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PowerState ISdl.GetPowerInfo(Ref seconds, Ref percent) - { - fixed (int* __dsl_percent = percent) - fixed (int* __dsl_seconds = seconds) - { - return (PowerState)((ISdl)this).GetPowerInfo(__dsl_seconds, __dsl_percent); - } - } + )(index); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPowerInfo")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PowerState GetPowerInfo(Ref seconds, Ref percent) => - DllImport.GetPowerInfo(seconds, percent); + public static sbyte* GetVideoDriverRaw(int index) => DllImport.GetVideoDriverRaw(index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Locale** ISdl.GetPreferredLocales(int* count) => + byte ISdl.GetWindowAspectRatio(WindowHandle window, float* min_aspect, float* max_aspect) => ( - (delegate* unmanaged)( - _slots[331] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[525] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[331] = nativeContext.LoadFunction("SDL_GetPreferredLocales", "SDL3") + : _slots[525] = nativeContext.LoadFunction("SDL_GetWindowAspectRatio", "SDL3") ) - )(count); + )(window, min_aspect, max_aspect); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Locale** GetPreferredLocales(int* count) => DllImport.GetPreferredLocales(count); + public static byte GetWindowAspectRatio( + WindowHandle window, + float* min_aspect, + float* max_aspect + ) => DllImport.GetWindowAspectRatio(window, min_aspect, max_aspect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetPreferredLocales(Ref count) + MaybeBool ISdl.GetWindowAspectRatio( + WindowHandle window, + Ref min_aspect, + Ref max_aspect + ) { - fixed (int* __dsl_count = count) + fixed (float* __dsl_max_aspect = max_aspect) + fixed (float* __dsl_min_aspect = min_aspect) { - return (Locale**)((ISdl)this).GetPreferredLocales(__dsl_count); + return (MaybeBool) + (byte)((ISdl)this).GetWindowAspectRatio(window, __dsl_min_aspect, __dsl_max_aspect); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPreferredLocales")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetPreferredLocales(Ref count) => - DllImport.GetPreferredLocales(count); + public static MaybeBool GetWindowAspectRatio( + WindowHandle window, + Ref min_aspect, + Ref max_aspect + ) => DllImport.GetWindowAspectRatio(window, min_aspect, max_aspect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetPrefPath( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app + byte ISdl.GetWindowBordersSize( + WindowHandle window, + int* top, + int* left, + int* bottom, + int* right ) => ( - (delegate* unmanaged)( - _slots[332] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[526] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[332] = nativeContext.LoadFunction("SDL_GetPrefPath", "SDL3") + : _slots[526] = nativeContext.LoadFunction("SDL_GetWindowBordersSize", "SDL3") ) - )(org, app); + )(window, top, left, bottom, right); - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetPrefPath( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app - ) => DllImport.GetPrefPath(org, app); + public static byte GetWindowBordersSize( + WindowHandle window, + int* top, + int* left, + int* bottom, + int* right + ) => DllImport.GetWindowBordersSize(window, top, left, bottom, right); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPrefPath( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app + MaybeBool ISdl.GetWindowBordersSize( + WindowHandle window, + Ref top, + Ref left, + Ref bottom, + Ref right ) { - fixed (sbyte* __dsl_app = app) - fixed (sbyte* __dsl_org = org) + fixed (int* __dsl_right = right) + fixed (int* __dsl_bottom = bottom) + fixed (int* __dsl_left = left) + fixed (int* __dsl_top = top) { - return (sbyte*)((ISdl)this).GetPrefPath(__dsl_org, __dsl_app); + return (MaybeBool) + (byte) + ((ISdl)this).GetWindowBordersSize( + window, + __dsl_top, + __dsl_left, + __dsl_bottom, + __dsl_right + ); } } - [return: NativeTypeName("char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrefPath")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPrefPath( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app - ) => DllImport.GetPrefPath(org, app); + public static MaybeBool GetWindowBordersSize( + WindowHandle window, + Ref top, + Ref left, + Ref bottom, + Ref right + ) => DllImport.GetWindowBordersSize(window, top, left, bottom, right); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetPrimaryDisplay() => + float ISdl.GetWindowDisplayScale(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[333] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[527] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[333] = nativeContext.LoadFunction("SDL_GetPrimaryDisplay", "SDL3") + : _slots[527] = nativeContext.LoadFunction("SDL_GetWindowDisplayScale", "SDL3") ) - )(); - - [return: NativeTypeName("SDL_DisplayID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimaryDisplay")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetPrimaryDisplay() => DllImport.GetPrimaryDisplay(); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetPrimarySelectionText() => (sbyte*)((ISdl)this).GetPrimarySelectionTextRaw(); + )(window); - [return: NativeTypeName("char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetPrimarySelectionText() => DllImport.GetPrimarySelectionText(); + public static float GetWindowDisplayScale(WindowHandle window) => + DllImport.GetWindowDisplayScale(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetPrimarySelectionTextRaw() => + ulong ISdl.GetWindowFlags(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[334] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[528] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[334] = nativeContext.LoadFunction( - "SDL_GetPrimarySelectionText", - "SDL3" - ) + : _slots[528] = nativeContext.LoadFunction("SDL_GetWindowFlags", "SDL3") ) - )(); - - [return: NativeTypeName("char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPrimarySelectionText")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetPrimarySelectionTextRaw() => DllImport.GetPrimarySelectionTextRaw(); + )(window); + [return: NativeTypeName("SDL_WindowFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PropertyType ISdl.GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => + public static ulong GetWindowFlags(WindowHandle window) => DllImport.GetWindowFlags(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + WindowHandle ISdl.GetWindowFromEvent([NativeTypeName("const SDL_Event *")] Event* @event) => ( - (delegate* unmanaged)( - _slots[335] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[529] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[335] = nativeContext.LoadFunction("SDL_GetPropertyType", "SDL3") + : _slots[529] = nativeContext.LoadFunction("SDL_GetWindowFromEvent", "SDL3") ) - )(props, name); + )(@event); - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.GetPropertyType(props, name); + public static WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Event* @event + ) => DllImport.GetWindowFromEvent(@event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PropertyType ISdl.GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) + WindowHandle ISdl.GetWindowFromEvent([NativeTypeName("const SDL_Event *")] Ref @event) { - fixed (sbyte* __dsl_name = name) + fixed (Event* __dsl_event = @event) { - return (PropertyType)((ISdl)this).GetPropertyType(props, __dsl_name); + return (WindowHandle)((ISdl)this).GetWindowFromEvent(__dsl_event); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetPropertyType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PropertyType GetPropertyType( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) => DllImport.GetPropertyType(props, name); + public static WindowHandle GetWindowFromEvent( + [NativeTypeName("const SDL_Event *")] Ref @event + ) => DllImport.GetWindowFromEvent(@event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetRealGamepadType(GamepadHandle gamepad) => + WindowHandle ISdl.GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => ( - (delegate* unmanaged)( - _slots[336] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[530] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[336] = nativeContext.LoadFunction("SDL_GetRealGamepadType", "SDL3") + : _slots[530] = nativeContext.LoadFunction("SDL_GetWindowFromID", "SDL3") ) - )(gamepad); + )(id); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadType")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetRealGamepadType(GamepadHandle gamepad) => - DllImport.GetRealGamepadType(gamepad); + public static WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => + DllImport.GetWindowFromID(id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadType ISdl.GetRealGamepadTypeForID([NativeTypeName("SDL_JoystickID")] uint instance_id) => + Ptr ISdl.GetWindowFullscreenMode(WindowHandle window) => + (DisplayMode*)((ISdl)this).GetWindowFullscreenModeRaw(window); + + [return: NativeTypeName("const SDL_DisplayMode *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr GetWindowFullscreenMode(WindowHandle window) => + DllImport.GetWindowFullscreenMode(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + DisplayMode* ISdl.GetWindowFullscreenModeRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[337] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[531] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[337] = nativeContext.LoadFunction( - "SDL_GetRealGamepadTypeForID", + : _slots[531] = nativeContext.LoadFunction( + "SDL_GetWindowFullscreenMode", "SDL3" ) ) - )(instance_id); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRealGamepadTypeForID")] + [return: NativeTypeName("const SDL_DisplayMode *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadType GetRealGamepadTypeForID( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.GetRealGamepadTypeForID(instance_id); + public static DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => + DllImport.GetWindowFullscreenModeRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int* X1, - int* Y1, - int* X2, - int* Y2 - ) => + void* ISdl.GetWindowICCProfile(WindowHandle window, [NativeTypeName("size_t *")] nuint* size) => ( - (delegate* unmanaged)( - _slots[338] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[532] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[338] = nativeContext.LoadFunction( - "SDL_GetRectAndLineIntersection", - "SDL3" - ) + : _slots[532] = nativeContext.LoadFunction("SDL_GetWindowICCProfile", "SDL3") ) - )(rect, X1, Y1, X2, Y2); + )(window, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int* X1, - int* Y1, - int* X2, - int* Y2 - ) => DllImport.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); + public static void* GetWindowICCProfile( + WindowHandle window, + [NativeTypeName("size_t *")] nuint* size + ) => DllImport.GetWindowICCProfile(window, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) + Ptr ISdl.GetWindowICCProfile(WindowHandle window, [NativeTypeName("size_t *")] Ref size) { - fixed (int* __dsl_Y2 = Y2) - fixed (int* __dsl_X2 = X2) - fixed (int* __dsl_Y1 = Y1) - fixed (int* __dsl_X1 = X1) - fixed (Rect* __dsl_rect = rect) + fixed (nuint* __dsl_size = size) { - return (MaybeBool) - (byte) - ((ISdl)this).GetRectAndLineIntersection( - __dsl_rect, - __dsl_X1, - __dsl_Y1, - __dsl_X2, - __dsl_Y2 - ); + return (void*)((ISdl)this).GetWindowICCProfile(window, __dsl_size); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectAndLineIntersection( - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) => DllImport.GetRectAndLineIntersection(rect, X1, Y1, X2, Y2); + public static Ptr GetWindowICCProfile( + WindowHandle window, + [NativeTypeName("size_t *")] Ref size + ) => DllImport.GetWindowICCProfile(window, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* rect, - float* X1, - float* Y1, - float* X2, - float* Y2 - ) => + uint ISdl.GetWindowID(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[339] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[533] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[339] = nativeContext.LoadFunction( - "SDL_GetRectAndLineIntersectionFloat", - "SDL3" - ) + : _slots[533] = nativeContext.LoadFunction("SDL_GetWindowID", "SDL3") ) - )(rect, X1, Y1, X2, Y2); + )(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [return: NativeTypeName("SDL_WindowID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* rect, - float* X1, - float* Y1, - float* X2, - float* Y2 - ) => DllImport.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); + public static uint GetWindowID(WindowHandle window) => DllImport.GetWindowID(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) - { - fixed (float* __dsl_Y2 = Y2) - fixed (float* __dsl_X2 = X2) - fixed (float* __dsl_Y1 = Y1) - fixed (float* __dsl_X1 = X1) - fixed (FRect* __dsl_rect = rect) - { - return (MaybeBool) - (byte) - ((ISdl)this).GetRectAndLineIntersectionFloat( - __dsl_rect, - __dsl_X1, - __dsl_Y1, - __dsl_X2, - __dsl_Y2 - ); - } - } + MaybeBool ISdl.GetWindowKeyboardGrab(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).GetWindowKeyboardGrabRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectAndLineIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectAndLineIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref rect, - Ref X1, - Ref Y1, - Ref X2, - Ref Y2 - ) => DllImport.GetRectAndLineIntersectionFloat(rect, X1, Y1, X2, Y2); + public static MaybeBool GetWindowKeyboardGrab(WindowHandle window) => + DllImport.GetWindowKeyboardGrab(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Point* points, - int count, - [NativeTypeName("const SDL_Rect *")] Rect* clip, - Rect* result - ) => + byte ISdl.GetWindowKeyboardGrabRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[340] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[534] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[340] = nativeContext.LoadFunction("SDL_GetRectEnclosingPoints", "SDL3") + : _slots[534] = nativeContext.LoadFunction("SDL_GetWindowKeyboardGrab", "SDL3") ) - )(points, count, clip, result); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Point* points, - int count, - [NativeTypeName("const SDL_Rect *")] Rect* clip, - Rect* result - ) => DllImport.GetRectEnclosingPoints(points, count, clip, result); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Ref points, - int count, - [NativeTypeName("const SDL_Rect *")] Ref clip, - Ref result - ) - { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_clip = clip) - fixed (Point* __dsl_points = points) - { - return (MaybeBool) - (byte) - ((ISdl)this).GetRectEnclosingPoints( - __dsl_points, - count, - __dsl_clip, - __dsl_result - ); - } - } + )(window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectEnclosingPoints( - [NativeTypeName("const SDL_Point *")] Ref points, - int count, - [NativeTypeName("const SDL_Rect *")] Ref clip, - Ref result - ) => DllImport.GetRectEnclosingPoints(points, count, clip, result); + public static byte GetWindowKeyboardGrabRaw(WindowHandle window) => + DllImport.GetWindowKeyboardGrabRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count, - [NativeTypeName("const SDL_FRect *")] FRect* clip, - FRect* result - ) => + byte ISdl.GetWindowMaximumSize(WindowHandle window, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[341] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[535] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[341] = nativeContext.LoadFunction( - "SDL_GetRectEnclosingPointsFloat", - "SDL3" - ) + : _slots[535] = nativeContext.LoadFunction("SDL_GetWindowMaximumSize", "SDL3") ) - )(points, count, clip, result); + )(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count, - [NativeTypeName("const SDL_FRect *")] FRect* clip, - FRect* result - ) => DllImport.GetRectEnclosingPointsFloat(points, count, clip, result); + public static byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => + DllImport.GetWindowMaximumSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count, - [NativeTypeName("const SDL_FRect *")] Ref clip, - Ref result - ) + MaybeBool ISdl.GetWindowMaximumSize(WindowHandle window, Ref w, Ref h) { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_clip = clip) - fixed (FPoint* __dsl_points = points) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { return (MaybeBool) - (byte) - ((ISdl)this).GetRectEnclosingPointsFloat( - __dsl_points, - count, - __dsl_clip, - __dsl_result - ); + (byte)((ISdl)this).GetWindowMaximumSize(window, __dsl_w, __dsl_h); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectEnclosingPointsFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectEnclosingPointsFloat( - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count, - [NativeTypeName("const SDL_FRect *")] Ref clip, - Ref result - ) => DllImport.GetRectEnclosingPointsFloat(points, count, clip, result); + public static MaybeBool GetWindowMaximumSize( + WindowHandle window, + Ref w, + Ref h + ) => DllImport.GetWindowMaximumSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => + byte ISdl.GetWindowMinimumSize(WindowHandle window, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[342] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[536] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[342] = nativeContext.LoadFunction("SDL_GetRectIntersection", "SDL3") + : _slots[536] = nativeContext.LoadFunction("SDL_GetWindowMinimumSize", "SDL3") ) - )(A, B, result); + )(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => DllImport.GetRectIntersection(A, B, result); + public static byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => + DllImport.GetWindowMinimumSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) + MaybeBool ISdl.GetWindowMinimumSize(WindowHandle window, Ref w, Ref h) { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { return (MaybeBool) - (byte)((ISdl)this).GetRectIntersection(__dsl_A, __dsl_B, __dsl_result); + (byte)((ISdl)this).GetWindowMinimumSize(window, __dsl_w, __dsl_h); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersection")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) => DllImport.GetRectIntersection(A, B, result); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => - ( - (delegate* unmanaged)( - _slots[343] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[343] = nativeContext.LoadFunction( - "SDL_GetRectIntersectionFloat", - "SDL3" - ) - ) - )(A, B, result); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => DllImport.GetRectIntersectionFloat(A, B, result); + public static MaybeBool GetWindowMinimumSize( + WindowHandle window, + Ref w, + Ref h + ) => DllImport.GetWindowMinimumSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) - { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) - { - return (MaybeBool) - (byte)((ISdl)this).GetRectIntersectionFloat(__dsl_A, __dsl_B, __dsl_result); - } - } + MaybeBool ISdl.GetWindowMouseGrab(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).GetWindowMouseGrabRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectIntersectionFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) => DllImport.GetRectIntersectionFloat(A, B, result); + public static MaybeBool GetWindowMouseGrab(WindowHandle window) => + DllImport.GetWindowMouseGrab(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => + byte ISdl.GetWindowMouseGrabRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[344] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[537] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[344] = nativeContext.LoadFunction("SDL_GetRectUnion", "SDL3") + : _slots[537] = nativeContext.LoadFunction("SDL_GetWindowMouseGrab", "SDL3") ) - )(A, B, result); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B, - Rect* result - ) => DllImport.GetRectUnion(A, B, result); + public static byte GetWindowMouseGrabRaw(WindowHandle window) => + DllImport.GetWindowMouseGrabRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) - { - fixed (Rect* __dsl_result = result) - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) - { - return (MaybeBool)(byte)((ISdl)this).GetRectUnion(__dsl_A, __dsl_B, __dsl_result); - } - } + Ptr ISdl.GetWindowMouseRect(WindowHandle window) => + (Rect*)((ISdl)this).GetWindowMouseRectRaw(window); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const SDL_Rect *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnion")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectUnion( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B, - Ref result - ) => DllImport.GetRectUnion(A, B, result); + public static Ptr GetWindowMouseRect(WindowHandle window) => + DllImport.GetWindowMouseRect(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => + Rect* ISdl.GetWindowMouseRectRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[345] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[538] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[345] = nativeContext.LoadFunction("SDL_GetRectUnionFloat", "SDL3") - ) - )(A, B, result); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B, - FRect* result - ) => DllImport.GetRectUnionFloat(A, B, result); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) - { - fixed (FRect* __dsl_result = result) - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) - { - return (MaybeBool) - (byte)((ISdl)this).GetRectUnionFloat(__dsl_A, __dsl_B, __dsl_result); - } - } + : _slots[538] = nativeContext.LoadFunction("SDL_GetWindowMouseRect", "SDL3") + ) + )(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRectUnionFloat")] + [return: NativeTypeName("const SDL_Rect *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRectUnionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B, - Ref result - ) => DllImport.GetRectUnionFloat(A, B, result); + public static Rect* GetWindowMouseRectRaw(WindowHandle window) => + DllImport.GetWindowMouseRectRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetRelativeMouseState(float* x, float* y) => + float ISdl.GetWindowOpacity(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[346] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[539] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[346] = nativeContext.LoadFunction("SDL_GetRelativeMouseState", "SDL3") + : _slots[539] = nativeContext.LoadFunction("SDL_GetWindowOpacity", "SDL3") ) - )(x, y); + )(window); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetRelativeMouseState(float* x, float* y) => - DllImport.GetRelativeMouseState(x, y); + public static float GetWindowOpacity(WindowHandle window) => DllImport.GetWindowOpacity(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetRelativeMouseState(Ref x, Ref y) - { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) - { - return (uint)((ISdl)this).GetRelativeMouseState(__dsl_x, __dsl_y); - } - } + WindowHandle ISdl.GetWindowParent(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[540] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[540] = nativeContext.LoadFunction("SDL_GetWindowParent", "SDL3") + ) + )(window); - [return: NativeTypeName("SDL_MouseButtonFlags")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRelativeMouseState")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetRelativeMouseState(Ref x, Ref y) => - DllImport.GetRelativeMouseState(x, y); + public static WindowHandle GetWindowParent(WindowHandle window) => + DllImport.GetWindowParent(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderClipRect(RendererHandle renderer, Rect* rect) => + float ISdl.GetWindowPixelDensity(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[347] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[541] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[347] = nativeContext.LoadFunction("SDL_GetRenderClipRect", "SDL3") + : _slots[541] = nativeContext.LoadFunction("SDL_GetWindowPixelDensity", "SDL3") ) - )(renderer, rect); + )(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderClipRect(RendererHandle renderer, Rect* rect) => - DllImport.GetRenderClipRect(renderer, rect); + public static float GetWindowPixelDensity(WindowHandle window) => + DllImport.GetWindowPixelDensity(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderClipRect(RendererHandle renderer, Ref rect) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)((ISdl)this).GetRenderClipRect(renderer, __dsl_rect); - } - } + PixelFormat ISdl.GetWindowPixelFormat(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[542] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[542] = nativeContext.LoadFunction("SDL_GetWindowPixelFormat", "SDL3") + ) + )(window); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderClipRect(RendererHandle renderer, Ref rect) => - DllImport.GetRenderClipRect(renderer, rect); + public static PixelFormat GetWindowPixelFormat(WindowHandle window) => + DllImport.GetWindowPixelFormat(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderColorScale(RendererHandle renderer, float* scale) => + byte ISdl.GetWindowPosition(WindowHandle window, int* x, int* y) => ( - (delegate* unmanaged)( - _slots[348] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[543] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[348] = nativeContext.LoadFunction("SDL_GetRenderColorScale", "SDL3") + : _slots[543] = nativeContext.LoadFunction("SDL_GetWindowPosition", "SDL3") ) - )(renderer, scale); + )(window, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderColorScale(RendererHandle renderer, float* scale) => - DllImport.GetRenderColorScale(renderer, scale); + public static byte GetWindowPosition(WindowHandle window, int* x, int* y) => + DllImport.GetWindowPosition(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderColorScale(RendererHandle renderer, Ref scale) + MaybeBool ISdl.GetWindowPosition(WindowHandle window, Ref x, Ref y) { - fixed (float* __dsl_scale = scale) + fixed (int* __dsl_y = y) + fixed (int* __dsl_x = x) { - return (MaybeBool)(byte)((ISdl)this).GetRenderColorScale(renderer, __dsl_scale); + return (MaybeBool)(byte)((ISdl)this).GetWindowPosition(window, __dsl_x, __dsl_y); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderColorScale(RendererHandle renderer, Ref scale) => - DllImport.GetRenderColorScale(renderer, scale); + public static MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) => + DllImport.GetWindowPosition(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => + uint ISdl.GetWindowProperties(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[349] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[544] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[349] = nativeContext.LoadFunction("SDL_GetRenderDrawBlendMode", "SDL3") + : _slots[544] = nativeContext.LoadFunction("SDL_GetWindowProperties", "SDL3") ) - )(renderer, blendMode); + )(window); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [return: NativeTypeName("SDL_PropertiesID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => DllImport.GetRenderDrawBlendMode(renderer, blendMode); + public static uint GetWindowProperties(WindowHandle window) => + DllImport.GetWindowProperties(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) - { - fixed (BlendMode* __dsl_blendMode = blendMode) - { - return (MaybeBool) - (byte)((ISdl)this).GetRenderDrawBlendMode(renderer, __dsl_blendMode); - } - } + MaybeBool ISdl.GetWindowRelativeMouseMode(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).GetWindowRelativeMouseModeRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => DllImport.GetRenderDrawBlendMode(renderer, blendMode); + public static MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => + DllImport.GetWindowRelativeMouseMode(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => + byte ISdl.GetWindowRelativeMouseModeRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[350] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[545] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[350] = nativeContext.LoadFunction("SDL_GetRenderDrawColor", "SDL3") + : _slots[545] = nativeContext.LoadFunction( + "SDL_GetWindowRelativeMouseMode", + "SDL3" + ) ) - )(renderer, r, g, b, a); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => DllImport.GetRenderDrawColor(renderer, r, g, b, a); + public static byte GetWindowRelativeMouseModeRaw(WindowHandle window) => + DllImport.GetWindowRelativeMouseModeRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) + WindowHandle* ISdl.GetWindows(int* count) => + ( + (delegate* unmanaged)( + _slots[546] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[546] = nativeContext.LoadFunction("SDL_GetWindows", "SDL3") + ) + )(count); + + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static WindowHandle* GetWindows(int* count) => DllImport.GetWindows(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.GetWindows(Ref count) { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) + fixed (int* __dsl_count = count) { - return (MaybeBool) - (byte)((ISdl)this).GetRenderDrawColor(renderer, __dsl_r, __dsl_g, __dsl_b, __dsl_a); + return (WindowHandle*)((ISdl)this).GetWindows(__dsl_count); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => DllImport.GetRenderDrawColor(renderer, r, g, b, a); + public static Ptr GetWindows(Ref count) => DllImport.GetWindows(count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderDrawColorFloat( - RendererHandle renderer, - float* r, - float* g, - float* b, - float* a - ) => + byte ISdl.GetWindowSafeArea(WindowHandle window, Rect* rect) => ( - (delegate* unmanaged)( - _slots[351] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[547] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[351] = nativeContext.LoadFunction( - "SDL_GetRenderDrawColorFloat", - "SDL3" - ) + : _slots[547] = nativeContext.LoadFunction("SDL_GetWindowSafeArea", "SDL3") ) - )(renderer, r, g, b, a); + )(window, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderDrawColorFloat( - RendererHandle renderer, - float* r, - float* g, - float* b, - float* a - ) => DllImport.GetRenderDrawColorFloat(renderer, r, g, b, a); + public static byte GetWindowSafeArea(WindowHandle window, Rect* rect) => + DllImport.GetWindowSafeArea(window, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderDrawColorFloat( - RendererHandle renderer, - Ref r, - Ref g, - Ref b, - Ref a - ) + MaybeBool ISdl.GetWindowSafeArea(WindowHandle window, Ref rect) { - fixed (float* __dsl_a = a) - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte) - ((ISdl)this).GetRenderDrawColorFloat( - renderer, - __dsl_r, - __dsl_g, - __dsl_b, - __dsl_a - ); + return (MaybeBool)(byte)((ISdl)this).GetWindowSafeArea(window, __dsl_rect); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDrawColorFloat")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderDrawColorFloat( - RendererHandle renderer, - Ref r, - Ref g, - Ref b, - Ref a - ) => DllImport.GetRenderDrawColorFloat(renderer, r, g, b, a); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRenderDriver(int index) => (sbyte*)((ISdl)this).GetRenderDriverRaw(index); - - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRenderDriver(int index) => DllImport.GetRenderDriver(index); + public static MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) => + DllImport.GetWindowSafeArea(window, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetRenderDriverRaw(int index) => + byte ISdl.GetWindowSize(WindowHandle window, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[352] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[548] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[352] = nativeContext.LoadFunction("SDL_GetRenderDriver", "SDL3") + : _slots[548] = nativeContext.LoadFunction("SDL_GetWindowSize", "SDL3") ) - )(index); + )(window, w, h); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderDriver")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetRenderDriverRaw(int index) => DllImport.GetRenderDriverRaw(index); + public static byte GetWindowSize(WindowHandle window, int* w, int* h) => + DllImport.GetWindowSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.GetRenderer(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[353] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[353] = nativeContext.LoadFunction("SDL_GetRenderer", "SDL3") - ) - )(window); + MaybeBool ISdl.GetWindowSize(WindowHandle window, Ref w, Ref h) + { + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) + { + return (MaybeBool)(byte)((ISdl)this).GetWindowSize(window, __dsl_w, __dsl_h); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderer")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle GetRenderer(WindowHandle window) => DllImport.GetRenderer(window); + public static MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) => + DllImport.GetWindowSize(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.GetRendererFromTexture(Texture* texture) => + byte ISdl.GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => ( - (delegate* unmanaged)( - _slots[354] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[549] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[354] = nativeContext.LoadFunction("SDL_GetRendererFromTexture", "SDL3") + : _slots[549] = nativeContext.LoadFunction("SDL_GetWindowSizeInPixels", "SDL3") ) - )(texture); + )(window, w, h); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle GetRendererFromTexture(Texture* texture) => - DllImport.GetRendererFromTexture(texture); + public static byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => + DllImport.GetWindowSizeInPixels(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - RendererHandle ISdl.GetRendererFromTexture(Ref texture) + MaybeBool ISdl.GetWindowSizeInPixels(WindowHandle window, Ref w, Ref h) { - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_h = h) + fixed (int* __dsl_w = w) { - return (RendererHandle)((ISdl)this).GetRendererFromTexture(__dsl_texture); + return (MaybeBool) + (byte)((ISdl)this).GetWindowSizeInPixels(window, __dsl_w, __dsl_h); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererFromTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static RendererHandle GetRendererFromTexture(Ref texture) => - DllImport.GetRendererFromTexture(texture); + public static MaybeBool GetWindowSizeInPixels( + WindowHandle window, + Ref w, + Ref h + ) => DllImport.GetWindowSizeInPixels(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRendererName(RendererHandle renderer) => - (sbyte*)((ISdl)this).GetRendererNameRaw(renderer); + Ptr ISdl.GetWindowSurface(WindowHandle window) => + (Surface*)((ISdl)this).GetWindowSurfaceRaw(window); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRendererName(RendererHandle renderer) => - DllImport.GetRendererName(renderer); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetRendererNameRaw(RendererHandle renderer) => - ( - (delegate* unmanaged)( - _slots[355] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[355] = nativeContext.LoadFunction("SDL_GetRendererName", "SDL3") - ) - )(renderer); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetRendererNameRaw(RendererHandle renderer) => - DllImport.GetRendererNameRaw(renderer); + public static Ptr GetWindowSurface(WindowHandle window) => + DllImport.GetWindowSurface(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetRendererProperties(RendererHandle renderer) => + Surface* ISdl.GetWindowSurfaceRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[356] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[550] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[356] = nativeContext.LoadFunction("SDL_GetRendererProperties", "SDL3") + : _slots[550] = nativeContext.LoadFunction("SDL_GetWindowSurface", "SDL3") ) - )(renderer); + )(window); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRendererProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetRendererProperties(RendererHandle renderer) => - DllImport.GetRendererProperties(renderer); + public static Surface* GetWindowSurfaceRaw(WindowHandle window) => + DllImport.GetWindowSurfaceRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderLogicalPresentation( - RendererHandle renderer, - int* w, - int* h, - RendererLogicalPresentation* mode - ) => + byte ISdl.GetWindowSurfaceVSync(WindowHandle window, int* vsync) => ( - (delegate* unmanaged)( - _slots[357] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[551] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[357] = nativeContext.LoadFunction( - "SDL_GetRenderLogicalPresentation", - "SDL3" - ) + : _slots[551] = nativeContext.LoadFunction("SDL_GetWindowSurfaceVSync", "SDL3") ) - )(renderer, w, h, mode); + )(window, vsync); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderLogicalPresentation( - RendererHandle renderer, - int* w, - int* h, - RendererLogicalPresentation* mode - ) => DllImport.GetRenderLogicalPresentation(renderer, w, h, mode); + public static byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => + DllImport.GetWindowSurfaceVSync(window, vsync); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderLogicalPresentation( - RendererHandle renderer, - Ref w, - Ref h, - Ref mode - ) + MaybeBool ISdl.GetWindowSurfaceVSync(WindowHandle window, Ref vsync) { - fixed (RendererLogicalPresentation* __dsl_mode = mode) - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (int* __dsl_vsync = vsync) { - return (MaybeBool) - (byte) - ((ISdl)this).GetRenderLogicalPresentation( - renderer, - __dsl_w, - __dsl_h, - __dsl_mode - ); + return (MaybeBool)(byte)((ISdl)this).GetWindowSurfaceVSync(window, __dsl_vsync); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentation")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderLogicalPresentation( - RendererHandle renderer, - Ref w, - Ref h, - Ref mode - ) => DllImport.GetRenderLogicalPresentation(renderer, w, h, mode); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => - ( - (delegate* unmanaged)( - _slots[358] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[358] = nativeContext.LoadFunction( - "SDL_GetRenderLogicalPresentationRect", - "SDL3" - ) - ) - )(renderer, rect); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderLogicalPresentationRect(RendererHandle renderer, FRect* rect) => - DllImport.GetRenderLogicalPresentationRect(renderer, rect); + public static MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) => + DllImport.GetWindowSurfaceVSync(window, vsync); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderLogicalPresentationRect(RendererHandle renderer, Ref rect) - { - fixed (FRect* __dsl_rect = rect) - { - return (MaybeBool) - (byte)((ISdl)this).GetRenderLogicalPresentationRect(renderer, __dsl_rect); - } - } + Ptr ISdl.GetWindowTitle(WindowHandle window) => + (sbyte*)((ISdl)this).GetWindowTitleRaw(window); - [return: NativeTypeName("bool")] + [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderLogicalPresentationRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderLogicalPresentationRect( - RendererHandle renderer, - Ref rect - ) => DllImport.GetRenderLogicalPresentationRect(renderer, rect); + public static Ptr GetWindowTitle(WindowHandle window) => + DllImport.GetWindowTitle(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRenderMetalCommandEncoder(RendererHandle renderer) => - (void*)((ISdl)this).GetRenderMetalCommandEncoderRaw(renderer); + sbyte* ISdl.GetWindowTitleRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[552] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[552] = nativeContext.LoadFunction("SDL_GetWindowTitle", "SDL3") + ) + )(window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] + [return: NativeTypeName("const char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRenderMetalCommandEncoder(RendererHandle renderer) => - DllImport.GetRenderMetalCommandEncoder(renderer); + public static sbyte* GetWindowTitleRaw(WindowHandle window) => + DllImport.GetWindowTitleRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => + GLContextStateHandle ISdl.GLCreateContext(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[359] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[553] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[359] = nativeContext.LoadFunction( - "SDL_GetRenderMetalCommandEncoder", - "SDL3" - ) + : _slots[553] = nativeContext.LoadFunction("SDL_GL_CreateContext", "SDL3") ) - )(renderer); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalCommandEncoder")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetRenderMetalCommandEncoderRaw(RendererHandle renderer) => - DllImport.GetRenderMetalCommandEncoderRaw(renderer); + public static GLContextStateHandle GLCreateContext(WindowHandle window) => + DllImport.GLCreateContext(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRenderMetalLayer(RendererHandle renderer) => - (void*)((ISdl)this).GetRenderMetalLayerRaw(renderer); + MaybeBool ISdl.GLDestroyContext( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => (MaybeBool)(byte)((ISdl)this).GLDestroyContextRaw(context); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRenderMetalLayer(RendererHandle renderer) => - DllImport.GetRenderMetalLayer(renderer); + public static MaybeBool GLDestroyContext( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => DllImport.GLDestroyContext(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetRenderMetalLayerRaw(RendererHandle renderer) => + byte ISdl.GLDestroyContextRaw([NativeTypeName("SDL_GLContext")] GLContextStateHandle context) => ( - (delegate* unmanaged)( - _slots[360] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[554] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[360] = nativeContext.LoadFunction("SDL_GetRenderMetalLayer", "SDL3") + : _slots[554] = nativeContext.LoadFunction("SDL_GL_DestroyContext", "SDL3") ) - )(renderer); + )(context); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderMetalLayer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetRenderMetalLayerRaw(RendererHandle renderer) => - DllImport.GetRenderMetalLayerRaw(renderer); + public static byte GLDestroyContextRaw( + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => DllImport.GLDestroyContextRaw(context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => + byte ISdl.GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => ( - (delegate* unmanaged)( - _slots[361] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[555] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[361] = nativeContext.LoadFunction("SDL_GetRenderOutputSize", "SDL3") + : _slots[555] = nativeContext.LoadFunction("SDL_GL_ExtensionSupported", "SDL3") ) - )(renderer, w, h); + )(extension); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderOutputSize(RendererHandle renderer, int* w, int* h) => - DllImport.GetRenderOutputSize(renderer, w, h); + public static byte GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => + DllImport.GLExtensionSupported(extension); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderOutputSize(RendererHandle renderer, Ref w, Ref h) + MaybeBool ISdl.GLExtensionSupported([NativeTypeName("const char *")] Ref extension) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (sbyte* __dsl_extension = extension) { - return (MaybeBool) - (byte)((ISdl)this).GetRenderOutputSize(renderer, __dsl_w, __dsl_h); + return (MaybeBool)(byte)((ISdl)this).GLExtensionSupported(__dsl_extension); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderOutputSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderOutputSize( - RendererHandle renderer, - Ref w, - Ref h - ) => DllImport.GetRenderOutputSize(renderer, w, h); + public static MaybeBool GLExtensionSupported( + [NativeTypeName("const char *")] Ref extension + ) => DllImport.GLExtensionSupported(extension); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderSafeArea(RendererHandle renderer, Rect* rect) => + byte ISdl.GLGetAttribute(GLAttr attr, int* value) => ( - (delegate* unmanaged)( - _slots[362] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[556] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[362] = nativeContext.LoadFunction("SDL_GetRenderSafeArea", "SDL3") + : _slots[556] = nativeContext.LoadFunction("SDL_GL_GetAttribute", "SDL3") ) - )(renderer, rect); + )(attr, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderSafeArea(RendererHandle renderer, Rect* rect) => - DllImport.GetRenderSafeArea(renderer, rect); + public static byte GLGetAttribute(GLAttr attr, int* value) => + DllImport.GLGetAttribute(attr, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderSafeArea(RendererHandle renderer, Ref rect) + MaybeBool ISdl.GLGetAttribute(GLAttr attr, Ref value) { - fixed (Rect* __dsl_rect = rect) + fixed (int* __dsl_value = value) { - return (MaybeBool)(byte)((ISdl)this).GetRenderSafeArea(renderer, __dsl_rect); + return (MaybeBool)(byte)((ISdl)this).GLGetAttribute(attr, __dsl_value); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderSafeArea(RendererHandle renderer, Ref rect) => - DllImport.GetRenderSafeArea(renderer, rect); + public static MaybeBool GLGetAttribute(GLAttr attr, Ref value) => + DllImport.GLGetAttribute(attr, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => + GLContextStateHandle ISdl.GLGetCurrentContext() => ( - (delegate* unmanaged)( - _slots[363] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[557] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[363] = nativeContext.LoadFunction("SDL_GetRenderScale", "SDL3") + : _slots[557] = nativeContext.LoadFunction("SDL_GL_GetCurrentContext", "SDL3") ) - )(renderer, scaleX, scaleY); + )(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [return: NativeTypeName("SDL_GLContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderScale(RendererHandle renderer, float* scaleX, float* scaleY) => - DllImport.GetRenderScale(renderer, scaleX, scaleY); + public static GLContextStateHandle GLGetCurrentContext() => DllImport.GLGetCurrentContext(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderScale( - RendererHandle renderer, - Ref scaleX, - Ref scaleY - ) - { - fixed (float* __dsl_scaleY = scaleY) - fixed (float* __dsl_scaleX = scaleX) - { - return (MaybeBool) - (byte)((ISdl)this).GetRenderScale(renderer, __dsl_scaleX, __dsl_scaleY); - } - } + WindowHandle ISdl.GLGetCurrentWindow() => + ( + (delegate* unmanaged)( + _slots[558] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[558] = nativeContext.LoadFunction("SDL_GL_GetCurrentWindow", "SDL3") + ) + )(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderScale( - RendererHandle renderer, - Ref scaleX, - Ref scaleY - ) => DllImport.GetRenderScale(renderer, scaleX, scaleY); + public static WindowHandle GLGetCurrentWindow() => DllImport.GLGetCurrentWindow(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRenderTarget(RendererHandle renderer) => - (Texture*)((ISdl)this).GetRenderTargetRaw(renderer); + FunctionPointer ISdl.GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + ( + (delegate* unmanaged)( + _slots[559] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[559] = nativeContext.LoadFunction("SDL_GL_GetProcAddress", "SDL3") + ) + )(proc); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRenderTarget(RendererHandle renderer) => - DllImport.GetRenderTarget(renderer); + public static FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + DllImport.GLGetProcAddress(proc); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Texture* ISdl.GetRenderTargetRaw(RendererHandle renderer) => - ( - (delegate* unmanaged)( - _slots[364] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[364] = nativeContext.LoadFunction("SDL_GetRenderTarget", "SDL3") - ) - )(renderer); + FunctionPointer ISdl.GLGetProcAddress([NativeTypeName("const char *")] Ref proc) + { + fixed (sbyte* __dsl_proc = proc) + { + return (FunctionPointer)((ISdl)this).GLGetProcAddress(__dsl_proc); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderTarget")] + [return: NativeTypeName("SDL_FunctionPointer")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Texture* GetRenderTargetRaw(RendererHandle renderer) => - DllImport.GetRenderTargetRaw(renderer); + public static FunctionPointer GLGetProcAddress( + [NativeTypeName("const char *")] Ref proc + ) => DllImport.GLGetProcAddress(proc); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderViewport(RendererHandle renderer, Rect* rect) => + byte ISdl.GLGetSwapInterval(int* interval) => ( - (delegate* unmanaged)( - _slots[365] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[560] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[365] = nativeContext.LoadFunction("SDL_GetRenderViewport", "SDL3") + : _slots[560] = nativeContext.LoadFunction("SDL_GL_GetSwapInterval", "SDL3") ) - )(renderer, rect); + )(interval); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderViewport(RendererHandle renderer, Rect* rect) => - DllImport.GetRenderViewport(renderer, rect); + public static byte GLGetSwapInterval(int* interval) => DllImport.GLGetSwapInterval(interval); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderViewport(RendererHandle renderer, Ref rect) + MaybeBool ISdl.GLGetSwapInterval(Ref interval) { - fixed (Rect* __dsl_rect = rect) + fixed (int* __dsl_interval = interval) { - return (MaybeBool)(byte)((ISdl)this).GetRenderViewport(renderer, __dsl_rect); + return (MaybeBool)(byte)((ISdl)this).GLGetSwapInterval(__dsl_interval); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderViewport(RendererHandle renderer, Ref rect) => - DllImport.GetRenderViewport(renderer, rect); + public static MaybeBool GLGetSwapInterval(Ref interval) => + DllImport.GLGetSwapInterval(interval); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetRenderVSync(RendererHandle renderer, int* vsync) => + byte ISdl.GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => ( - (delegate* unmanaged)( - _slots[366] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[561] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[366] = nativeContext.LoadFunction("SDL_GetRenderVSync", "SDL3") + : _slots[561] = nativeContext.LoadFunction("SDL_GL_LoadLibrary", "SDL3") ) - )(renderer, vsync); + )(path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetRenderVSync(RendererHandle renderer, int* vsync) => - DllImport.GetRenderVSync(renderer, vsync); + public static byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + DllImport.GLLoadLibrary(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetRenderVSync(RendererHandle renderer, Ref vsync) + MaybeBool ISdl.GLLoadLibrary([NativeTypeName("const char *")] Ref path) { - fixed (int* __dsl_vsync = vsync) + fixed (sbyte* __dsl_path = path) { - return (MaybeBool)(byte)((ISdl)this).GetRenderVSync(renderer, __dsl_vsync); + return (MaybeBool)(byte)((ISdl)this).GLLoadLibrary(__dsl_path); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetRenderVSync(RendererHandle renderer, Ref vsync) => - DllImport.GetRenderVSync(renderer, vsync); + public static MaybeBool GLLoadLibrary([NativeTypeName("const char *")] Ref path) => + DllImport.GLLoadLibrary(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetRenderWindow(RendererHandle renderer) => - ( - (delegate* unmanaged)( - _slots[367] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[367] = nativeContext.LoadFunction("SDL_GetRenderWindow", "SDL3") - ) - )(renderer); + MaybeBool ISdl.GLMakeCurrent( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => (MaybeBool)(byte)((ISdl)this).GLMakeCurrentRaw(window, context); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRenderWindow")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetRenderWindow(RendererHandle renderer) => - DllImport.GetRenderWindow(renderer); + public static MaybeBool GLMakeCurrent( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => DllImport.GLMakeCurrent(window, context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetRevision() => (sbyte*)((ISdl)this).GetRevisionRaw(); + byte ISdl.GLMakeCurrentRaw( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => + ( + (delegate* unmanaged)( + _slots[562] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[562] = nativeContext.LoadFunction("SDL_GL_MakeCurrent", "SDL3") + ) + )(window, context); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetRevision() => DllImport.GetRevision(); + public static byte GLMakeCurrentRaw( + WindowHandle window, + [NativeTypeName("SDL_GLContext")] GLContextStateHandle context + ) => DllImport.GLMakeCurrentRaw(window, context); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetRevisionRaw() => + void ISdl.GLResetAttributes() => ( - (delegate* unmanaged)( - _slots[368] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[563] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[368] = nativeContext.LoadFunction("SDL_GetRevision", "SDL3") + : _slots[563] = nativeContext.LoadFunction("SDL_GL_ResetAttributes", "SDL3") ) )(); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRevision")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetRevisionRaw() => DllImport.GetRevisionRaw(); + public static void GLResetAttributes() => DllImport.GLResetAttributes(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => + MaybeBool ISdl.GLSetAttribute(GLAttr attr, int value) => + (MaybeBool)(byte)((ISdl)this).GLSetAttributeRaw(attr, value); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool GLSetAttribute(GLAttr attr, int value) => + DllImport.GLSetAttribute(attr, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.GLSetAttributeRaw(GLAttr attr, int value) => ( - (delegate* unmanaged)( - _slots[369] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[564] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[369] = nativeContext.LoadFunction("SDL_GetRGB", "SDL3") + : _slots[564] = nativeContext.LoadFunction("SDL_GL_SetAttribute", "SDL3") ) - )(pixel, format, palette, r, g, b); + )(attr, value); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => DllImport.GetRGB(pixel, format, palette, r, g, b); + public static byte GLSetAttributeRaw(GLAttr attr, int value) => + DllImport.GLSetAttributeRaw(attr, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) - { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) - { - ((ISdl)this).GetRGB(pixel, __dsl_format, __dsl_palette, __dsl_r, __dsl_g, __dsl_b); - } - } + MaybeBool ISdl.GLSetSwapInterval(int interval) => + (MaybeBool)(byte)((ISdl)this).GLSetSwapIntervalRaw(interval); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetRGB( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => DllImport.GetRGB(pixel, format, palette, r, g, b); + public static MaybeBool GLSetSwapInterval(int interval) => + DllImport.GLSetSwapInterval(interval); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => + byte ISdl.GLSetSwapIntervalRaw(int interval) => ( - (delegate* unmanaged< - uint, - PixelFormatDetails*, - Palette*, - byte*, - byte*, - byte*, - byte*, - void>)( - _slots[370] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[565] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[370] = nativeContext.LoadFunction("SDL_GetRGBA", "SDL3") + : _slots[565] = nativeContext.LoadFunction("SDL_GL_SetSwapInterval", "SDL3") ) - )(pixel, format, palette, r, g, b, a); + )(interval); - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => DllImport.GetRgba(pixel, format, palette, r, g, b, a); + public static byte GLSetSwapIntervalRaw(int interval) => + DllImport.GLSetSwapIntervalRaw(interval); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) - { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) - { - ((ISdl)this).GetRgba( - pixel, - __dsl_format, - __dsl_palette, - __dsl_r, - __dsl_g, - __dsl_b, - __dsl_a - ); - } - } + MaybeBool ISdl.GLSwapWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).GLSwapWindowRaw(window); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GetRgba( - [NativeTypeName("Uint32")] uint pixel, - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => DllImport.GetRgba(pixel, format, palette, r, g, b, a); + public static MaybeBool GLSwapWindow(WindowHandle window) => + DllImport.GLSwapWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Sandbox ISdl.GetSandbox() => + byte ISdl.GLSwapWindowRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[371] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[566] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[371] = nativeContext.LoadFunction("SDL_GetSandbox", "SDL3") + : _slots[566] = nativeContext.LoadFunction("SDL_GL_SwapWindow", "SDL3") ) - )(); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSandbox")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Sandbox GetSandbox() => DllImport.GetSandbox(); + public static byte GLSwapWindowRaw(WindowHandle window) => DllImport.GLSwapWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Scancode ISdl.GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] ushort* modstate - ) => + void ISdl.GLUnloadLibrary() => ( - (delegate* unmanaged)( - _slots[372] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[567] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[372] = nativeContext.LoadFunction("SDL_GetScancodeFromKey", "SDL3") + : _slots[567] = nativeContext.LoadFunction("SDL_GL_UnloadLibrary", "SDL3") ) - )(key, modstate); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] ushort* modstate - ) => DllImport.GetScancodeFromKey(key, modstate); + public static void GLUnloadLibrary() => DllImport.GLUnloadLibrary(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Scancode ISdl.GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] Ref modstate + sbyte** ISdl.GlobDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => + ( + (delegate* unmanaged)( + _slots[568] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[568] = nativeContext.LoadFunction("SDL_GlobDirectory", "SDL3") + ) + )(path, pattern, flags, count); + + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte** GlobDirectory( + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => DllImport.GlobDirectory(path, pattern, flags, count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr2D ISdl.GlobDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count ) { - fixed (ushort* __dsl_modstate = modstate) + fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_pattern = pattern) + fixed (sbyte* __dsl_path = path) { - return (Scancode)((ISdl)this).GetScancodeFromKey(key, __dsl_modstate); + return (sbyte**) + ((ISdl)this).GlobDirectory(__dsl_path, __dsl_pattern, flags, __dsl_count); } } + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Scancode GetScancodeFromKey( - [NativeTypeName("SDL_Keycode")] uint key, - [NativeTypeName("SDL_Keymod *")] Ref modstate - ) => DllImport.GetScancodeFromKey(key, modstate); + public static Ptr2D GlobDirectory( + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) => DllImport.GlobDirectory(path, pattern, flags, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Scancode ISdl.GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => + sbyte** ISdl.GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => ( - (delegate* unmanaged)( - _slots[373] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[569] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[373] = nativeContext.LoadFunction("SDL_GetScancodeFromName", "SDL3") + : _slots[569] = nativeContext.LoadFunction("SDL_GlobStorageDirectory", "SDL3") ) - )(name); + )(storage, path, pattern, flags, count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [return: NativeTypeName("char **")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Scancode GetScancodeFromName([NativeTypeName("const char *")] sbyte* name) => - DllImport.GetScancodeFromName(name); + public static sbyte** GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + [NativeTypeName("const char *")] sbyte* pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + int* count + ) => DllImport.GlobStorageDirectory(storage, path, pattern, flags, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Scancode ISdl.GetScancodeFromName([NativeTypeName("const char *")] Ref name) + Ptr2D ISdl.GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) { - fixed (sbyte* __dsl_name = name) + fixed (int* __dsl_count = count) + fixed (sbyte* __dsl_pattern = pattern) + fixed (sbyte* __dsl_path = path) { - return (Scancode)((ISdl)this).GetScancodeFromName(__dsl_name); + return (sbyte**) + ((ISdl)this).GlobStorageDirectory( + storage, + __dsl_path, + __dsl_pattern, + flags, + __dsl_count + ); } } + [return: NativeTypeName("char **")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeFromName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Scancode GetScancodeFromName([NativeTypeName("const char *")] Ref name) => - DllImport.GetScancodeFromName(name); + public static Ptr2D GlobStorageDirectory( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + [NativeTypeName("const char *")] Ref pattern, + [NativeTypeName("SDL_GlobFlags")] uint flags, + Ref count + ) => DllImport.GlobStorageDirectory(storage, path, pattern, flags, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetScancodeName(Scancode scancode) => - (sbyte*)((ISdl)this).GetScancodeNameRaw(scancode); + MaybeBool ISdl.GPUSupportsProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + (MaybeBool)(byte)((ISdl)this).GPUSupportsPropertiesRaw(props); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetScancodeName(Scancode scancode) => - DllImport.GetScancodeName(scancode); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetScancodeNameRaw(Scancode scancode) => - ( - (delegate* unmanaged)( - _slots[374] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[374] = nativeContext.LoadFunction("SDL_GetScancodeName", "SDL3") - ) - )(scancode); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetScancodeNameRaw(Scancode scancode) => - DllImport.GetScancodeNameRaw(scancode); + public static MaybeBool GPUSupportsProperties( + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.GPUSupportsProperties(props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetSemaphoreValue(SemaphoreHandle sem) => + byte ISdl.GPUSupportsPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => ( - (delegate* unmanaged)( - _slots[375] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[570] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[375] = nativeContext.LoadFunction("SDL_GetSemaphoreValue", "SDL3") + : _slots[570] = nativeContext.LoadFunction("SDL_GPUSupportsProperties", "SDL3") ) - )(sem); + )(props); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSemaphoreValue")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetSemaphoreValue(SemaphoreHandle sem) => DllImport.GetSemaphoreValue(sem); + public static byte GPUSupportsPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + DllImport.GPUSupportsPropertiesRaw(props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSensorData(SensorHandle sensor, float* data, int num_values) => + byte ISdl.GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ) => ( - (delegate* unmanaged)( - _slots[376] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[571] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[376] = nativeContext.LoadFunction("SDL_GetSensorData", "SDL3") + : _slots[571] = nativeContext.LoadFunction( + "SDL_GPUSupportsShaderFormats", + "SDL3" + ) ) - )(sensor, data, num_values); + )(format_flags, name); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSensorData(SensorHandle sensor, float* data, int num_values) => - DllImport.GetSensorData(sensor, data, num_values); + public static byte GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.GPUSupportsShaderFormats(format_flags, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSensorData(SensorHandle sensor, Ref data, int num_values) + MaybeBool ISdl.GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ) { - fixed (float* __dsl_data = data) + fixed (sbyte* __dsl_name = name) { return (MaybeBool) - (byte)((ISdl)this).GetSensorData(sensor, __dsl_data, num_values); + (byte)((ISdl)this).GPUSupportsShaderFormats(format_flags, __dsl_name); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorData")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSensorData( - SensorHandle sensor, - Ref data, - int num_values - ) => DllImport.GetSensorData(sensor, data, num_values); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SensorHandle ISdl.GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[377] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[377] = nativeContext.LoadFunction("SDL_GetSensorFromID", "SDL3") - ) - )(instance_id); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorFromID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUSupportsShaderFormats")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SensorHandle GetSensorFromID([NativeTypeName("SDL_SensorID")] uint instance_id) => - DllImport.GetSensorFromID(instance_id); + public static MaybeBool GPUSupportsShaderFormats( + [NativeTypeName("SDL_GPUShaderFormat")] uint format_flags, + [NativeTypeName("const char *")] Ref name + ) => DllImport.GPUSupportsShaderFormats(format_flags, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetSensorID(SensorHandle sensor) => + uint ISdl.GPUTextureFormatTexelBlockSize(GPUTextureFormat format) => ( - (delegate* unmanaged)( - _slots[378] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[572] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[378] = nativeContext.LoadFunction("SDL_GetSensorID", "SDL3") + : _slots[572] = nativeContext.LoadFunction( + "SDL_GPUTextureFormatTexelBlockSize", + "SDL3" + ) ) - )(sensor); - - [return: NativeTypeName("SDL_SensorID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorID")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetSensorID(SensorHandle sensor) => DllImport.GetSensorID(sensor); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetSensorName(SensorHandle sensor) => - (sbyte*)((ISdl)this).GetSensorNameRaw(sensor); + )(format); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureFormatTexelBlockSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetSensorName(SensorHandle sensor) => DllImport.GetSensorName(sensor); + public static uint GPUTextureFormatTexelBlockSize(GPUTextureFormat format) => + DllImport.GPUTextureFormatTexelBlockSize(format); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetSensorNameForID([NativeTypeName("SDL_SensorID")] uint instance_id) => - (sbyte*)((ISdl)this).GetSensorNameForIDRaw(instance_id); + MaybeBool ISdl.GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => + (MaybeBool) + (byte)((ISdl)this).GPUTextureSupportsFormatRaw(device, format, type, usage); - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetSensorNameForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => DllImport.GetSensorNameForID(instance_id); + public static MaybeBool GPUTextureSupportsFormat( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => DllImport.GPUTextureSupportsFormat(device, format, type, usage); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => + byte ISdl.GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => ( - (delegate* unmanaged)( - _slots[380] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[573] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[380] = nativeContext.LoadFunction("SDL_GetSensorNameForID", "SDL3") + : _slots[573] = nativeContext.LoadFunction( + "SDL_GPUTextureSupportsFormat", + "SDL3" + ) ) - )(instance_id); + )(device, format, type, usage); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNameForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetSensorNameForIDRaw([NativeTypeName("SDL_SensorID")] uint instance_id) => - DllImport.GetSensorNameForIDRaw(instance_id); + public static byte GPUTextureSupportsFormatRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUTextureType type, + [NativeTypeName("SDL_GPUTextureUsageFlags")] uint usage + ) => DllImport.GPUTextureSupportsFormatRaw(device, format, type, usage); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetSensorNameRaw(SensorHandle sensor) => - ( - (delegate* unmanaged)( - _slots[379] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[379] = nativeContext.LoadFunction("SDL_GetSensorName", "SDL3") - ) - )(sensor); + MaybeBool ISdl.GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => + (MaybeBool) + (byte)((ISdl)this).GPUTextureSupportsSampleCountRaw(device, format, sample_count); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorName")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetSensorNameRaw(SensorHandle sensor) => - DllImport.GetSensorNameRaw(sensor); + public static MaybeBool GPUTextureSupportsSampleCount( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => DllImport.GPUTextureSupportsSampleCount(device, format, sample_count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetSensorNonPortableType(SensorHandle sensor) => + byte ISdl.GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => ( - (delegate* unmanaged)( - _slots[381] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[574] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[381] = nativeContext.LoadFunction( - "SDL_GetSensorNonPortableType", + : _slots[574] = nativeContext.LoadFunction( + "SDL_GPUTextureSupportsSampleCount", "SDL3" ) ) - )(sensor); + )(device, format, sample_count); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableType")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_GPUTextureSupportsSampleCount")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetSensorNonPortableType(SensorHandle sensor) => - DllImport.GetSensorNonPortableType(sensor); + public static byte GPUTextureSupportsSampleCountRaw( + GPUDeviceHandle device, + GPUTextureFormat format, + GPUSampleCount sample_count + ) => DllImport.GPUTextureSupportsSampleCountRaw(device, format, sample_count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetSensorNonPortableTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => + void ISdl.GuidToString(Guid guid, [NativeTypeName("char *")] sbyte* pszGUID, int cbGUID) => ( - (delegate* unmanaged)( - _slots[382] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[575] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[382] = nativeContext.LoadFunction( - "SDL_GetSensorNonPortableTypeForID", - "SDL3" - ) + : _slots[575] = nativeContext.LoadFunction("SDL_GUIDToString", "SDL3") ) - )(instance_id); + )(guid, pszGUID, cbGUID); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorNonPortableTypeForID")] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetSensorNonPortableTypeForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => DllImport.GetSensorNonPortableTypeForID(instance_id); + public static void GuidToString( + Guid guid, + [NativeTypeName("char *")] sbyte* pszGUID, + int cbGUID + ) => DllImport.GuidToString(guid, pszGUID, cbGUID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetSensorProperties(SensorHandle sensor) => - ( - (delegate* unmanaged)( - _slots[383] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[383] = nativeContext.LoadFunction("SDL_GetSensorProperties", "SDL3") - ) - )(sensor); + void ISdl.GuidToString(Guid guid, [NativeTypeName("char *")] Ref pszGUID, int cbGUID) + { + fixed (sbyte* __dsl_pszGUID = pszGUID) + { + ((ISdl)this).GuidToString(guid, __dsl_pszGUID, cbGUID); + } + } - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorProperties")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetSensorProperties(SensorHandle sensor) => - DllImport.GetSensorProperties(sensor); + public static void GuidToString( + Guid guid, + [NativeTypeName("char *")] Ref pszGUID, + int cbGUID + ) => DllImport.GuidToString(guid, pszGUID, cbGUID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint* ISdl.GetSensors(int* count) => + byte ISdl.HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => ( - (delegate* unmanaged)( - _slots[384] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[576] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[384] = nativeContext.LoadFunction("SDL_GetSensors", "SDL3") + : _slots[576] = nativeContext.LoadFunction("SDL_HapticEffectSupported", "SDL3") ) - )(count); + )(haptic, effect); - [return: NativeTypeName("SDL_SensorID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint* GetSensors(int* count) => DllImport.GetSensors(count); + public static byte HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect + ) => DllImport.HapticEffectSupported(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetSensors(Ref count) + MaybeBool ISdl.HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) { - fixed (int* __dsl_count = count) + fixed (HapticEffect* __dsl_effect = effect) { - return (uint*)((ISdl)this).GetSensors(__dsl_count); + return (MaybeBool)(byte)((ISdl)this).HapticEffectSupported(haptic, __dsl_effect); } } - [return: NativeTypeName("SDL_SensorID *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensors")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetSensors(Ref count) => DllImport.GetSensors(count); + public static MaybeBool HapticEffectSupported( + HapticHandle haptic, + [NativeTypeName("const SDL_HapticEffect *")] Ref effect + ) => DllImport.HapticEffectSupported(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SensorType ISdl.GetSensorType(SensorHandle sensor) => - ( - (delegate* unmanaged)( - _slots[385] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[385] = nativeContext.LoadFunction("SDL_GetSensorType", "SDL3") - ) - )(sensor); + MaybeBool ISdl.HapticRumbleSupported(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).HapticRumbleSupportedRaw(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorType")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SensorType GetSensorType(SensorHandle sensor) => DllImport.GetSensorType(sensor); + public static MaybeBool HapticRumbleSupported(HapticHandle haptic) => + DllImport.HapticRumbleSupported(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SensorType ISdl.GetSensorTypeForID([NativeTypeName("SDL_SensorID")] uint instance_id) => + byte ISdl.HapticRumbleSupportedRaw(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[386] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[577] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[386] = nativeContext.LoadFunction("SDL_GetSensorTypeForID", "SDL3") + : _slots[577] = nativeContext.LoadFunction("SDL_HapticRumbleSupported", "SDL3") ) - )(instance_id); + )(haptic); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSensorTypeForID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SensorType GetSensorTypeForID( - [NativeTypeName("SDL_SensorID")] uint instance_id - ) => DllImport.GetSensorTypeForID(instance_id); + public static byte HapticRumbleSupportedRaw(HapticHandle haptic) => + DllImport.HapticRumbleSupportedRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetSilenceValueForFormat(AudioFormat format) => - ( - (delegate* unmanaged)( - _slots[387] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[387] = nativeContext.LoadFunction( - "SDL_GetSilenceValueForFormat", - "SDL3" - ) - ) - )(format); + MaybeBool ISdl.HasAltiVec() => (MaybeBool)(byte)((ISdl)this).HasAltiVecRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSilenceValueForFormat")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetSilenceValueForFormat(AudioFormat format) => - DllImport.GetSilenceValueForFormat(format); + public static MaybeBool HasAltiVec() => DllImport.HasAltiVec(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - nuint ISdl.GetSimdAlignment() => + byte ISdl.HasAltiVecRaw() => ( - (delegate* unmanaged)( - _slots[388] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[578] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[388] = nativeContext.LoadFunction("SDL_GetSIMDAlignment", "SDL3") + : _slots[578] = nativeContext.LoadFunction("SDL_HasAltiVec", "SDL3") ) )(); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSIMDAlignment")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static nuint GetSimdAlignment() => DllImport.GetSimdAlignment(); + public static byte HasAltiVecRaw() => DllImport.HasAltiVecRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("Uint64 *")] ulong* length - ) => + MaybeBool ISdl.HasArmsimd() => (MaybeBool)(byte)((ISdl)this).HasArmsimdRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool HasArmsimd() => DllImport.HasArmsimd(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasArmsimdRaw() => ( - (delegate* unmanaged)( - _slots[389] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[579] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[389] = nativeContext.LoadFunction("SDL_GetStorageFileSize", "SDL3") + : _slots[579] = nativeContext.LoadFunction("SDL_HasARMSIMD", "SDL3") ) - )(storage, path, length); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("Uint64 *")] ulong* length - ) => DllImport.GetStorageFileSize(storage, path, length); + public static byte HasArmsimdRaw() => DllImport.HasArmsimdRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("Uint64 *")] Ref length - ) - { - fixed (ulong* __dsl_length = length) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)((ISdl)this).GetStorageFileSize(storage, __dsl_path, __dsl_length); - } - } + MaybeBool ISdl.HasAVX() => (MaybeBool)(byte)((ISdl)this).HasAVXRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageFileSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetStorageFileSize( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("Uint64 *")] Ref length - ) => DllImport.GetStorageFileSize(storage, path, length); + public static MaybeBool HasAVX() => DllImport.HasAVX(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - PathInfo* info - ) => + MaybeBool ISdl.HasAVX2() => (MaybeBool)(byte)((ISdl)this).HasAVX2Raw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool HasAVX2() => DllImport.HasAVX2(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasAVX2Raw() => ( - (delegate* unmanaged)( - _slots[390] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[581] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[390] = nativeContext.LoadFunction("SDL_GetStoragePathInfo", "SDL3") + : _slots[581] = nativeContext.LoadFunction("SDL_HasAVX2", "SDL3") ) - )(storage, path, info); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - PathInfo* info - ) => DllImport.GetStoragePathInfo(storage, path, info); + public static byte HasAVX2Raw() => DllImport.HasAVX2Raw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref info - ) - { - fixed (PathInfo* __dsl_info = info) - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool) - (byte)((ISdl)this).GetStoragePathInfo(storage, __dsl_path, __dsl_info); - } - } + MaybeBool ISdl.HasAVX512F() => (MaybeBool)(byte)((ISdl)this).HasAVX512FRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStoragePathInfo")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetStoragePathInfo( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref info - ) => DllImport.GetStoragePathInfo(storage, path, info); + public static MaybeBool HasAVX512F() => DllImport.HasAVX512F(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetStorageSpaceRemaining(StorageHandle storage) => + byte ISdl.HasAVX512FRaw() => ( - (delegate* unmanaged)( - _slots[391] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[582] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[391] = nativeContext.LoadFunction( - "SDL_GetStorageSpaceRemaining", - "SDL3" - ) + : _slots[582] = nativeContext.LoadFunction("SDL_HasAVX512F", "SDL3") ) - )(storage); + )(); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStorageSpaceRemaining")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte HasAVX512FRaw() => DllImport.HasAVX512FRaw(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasAVXRaw() => + ( + (delegate* unmanaged)( + _slots[580] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[580] = nativeContext.LoadFunction("SDL_HasAVX", "SDL3") + ) + )(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetStorageSpaceRemaining(StorageHandle storage) => - DllImport.GetStorageSpaceRemaining(storage); + public static byte HasAVXRaw() => DllImport.HasAVXRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* default_value - ) => + byte ISdl.HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => ( - (delegate* unmanaged)( - _slots[392] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[583] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[392] = nativeContext.LoadFunction("SDL_GetStringProperty", "SDL3") + : _slots[583] = nativeContext.LoadFunction("SDL_HasClipboardData", "SDL3") ) - )(props, name, default_value); + )(mime_type); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* default_value - ) => DllImport.GetStringProperty(props, name, default_value); + public static byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => + DllImport.HasClipboardData(mime_type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref default_value - ) + MaybeBool ISdl.HasClipboardData([NativeTypeName("const char *")] Ref mime_type) { - fixed (sbyte* __dsl_default_value = default_value) - fixed (sbyte* __dsl_name = name) + fixed (sbyte* __dsl_mime_type = mime_type) { - return (sbyte*)((ISdl)this).GetStringProperty(props, __dsl_name, __dsl_default_value); + return (MaybeBool)(byte)((ISdl)this).HasClipboardData(__dsl_mime_type); } } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref default_value - ) => DllImport.GetStringProperty(props, name, default_value); + public static MaybeBool HasClipboardData( + [NativeTypeName("const char *")] Ref mime_type + ) => DllImport.HasClipboardData(mime_type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8 *")] byte* alpha) => + MaybeBool ISdl.HasClipboardText() => + (MaybeBool)(byte)((ISdl)this).HasClipboardTextRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool HasClipboardText() => DllImport.HasClipboardText(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasClipboardTextRaw() => ( - (delegate* unmanaged)( - _slots[393] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[584] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[393] = nativeContext.LoadFunction("SDL_GetSurfaceAlphaMod", "SDL3") + : _slots[584] = nativeContext.LoadFunction("SDL_HasClipboardText", "SDL3") ) - )(surface, alpha); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSurfaceAlphaMod( - Surface* surface, - [NativeTypeName("Uint8 *")] byte* alpha - ) => DllImport.GetSurfaceAlphaMod(surface, alpha); + public static byte HasClipboardTextRaw() => DllImport.HasClipboardTextRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref alpha - ) - { - fixed (byte* __dsl_alpha = alpha) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).GetSurfaceAlphaMod(__dsl_surface, __dsl_alpha); - } - } + MaybeBool ISdl.HasEvent([NativeTypeName("Uint32")] uint type) => + (MaybeBool)(byte)((ISdl)this).HasEventRaw(type); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref alpha - ) => DllImport.GetSurfaceAlphaMod(surface, alpha); + public static MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => + DllImport.HasEvent(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => + byte ISdl.HasEventRaw([NativeTypeName("Uint32")] uint type) => ( - (delegate* unmanaged)( - _slots[394] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[585] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[394] = nativeContext.LoadFunction("SDL_GetSurfaceBlendMode", "SDL3") + : _slots[585] = nativeContext.LoadFunction("SDL_HasEvent", "SDL3") ) - )(surface, blendMode); + )(type); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => DllImport.GetSurfaceBlendMode(surface, blendMode); + public static byte HasEventRaw([NativeTypeName("Uint32")] uint type) => + DllImport.HasEventRaw(type); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) - { - fixed (BlendMode* __dsl_blendMode = blendMode) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).GetSurfaceBlendMode(__dsl_surface, __dsl_blendMode); - } - } + MaybeBool ISdl.HasEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => (MaybeBool)(byte)((ISdl)this).HasEventsRaw(minType, maxType); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => DllImport.GetSurfaceBlendMode(surface, blendMode); + public static MaybeBool HasEvents( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => DllImport.HasEvents(minType, maxType); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSurfaceClipRect(Surface* surface, Rect* rect) => + byte ISdl.HasEventsRaw( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => ( - (delegate* unmanaged)( - _slots[395] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[586] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[395] = nativeContext.LoadFunction("SDL_GetSurfaceClipRect", "SDL3") + : _slots[586] = nativeContext.LoadFunction("SDL_HasEvents", "SDL3") ) - )(surface, rect); + )(minType, maxType); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSurfaceClipRect(Surface* surface, Rect* rect) => - DllImport.GetSurfaceClipRect(surface, rect); + public static byte HasEventsRaw( + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => DllImport.HasEventsRaw(minType, maxType); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSurfaceClipRect(Ref surface, Ref rect) - { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).GetSurfaceClipRect(__dsl_surface, __dsl_rect); - } - } + MaybeBool ISdl.HasGamepad() => (MaybeBool)(byte)((ISdl)this).HasGamepadRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSurfaceClipRect(Ref surface, Ref rect) => - DllImport.GetSurfaceClipRect(surface, rect); + public static MaybeBool HasGamepad() => DllImport.HasGamepad(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSurfaceColorKey(Surface* surface, [NativeTypeName("Uint32 *")] uint* key) => + byte ISdl.HasGamepadRaw() => ( - (delegate* unmanaged)( - _slots[396] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[587] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[396] = nativeContext.LoadFunction("SDL_GetSurfaceColorKey", "SDL3") + : _slots[587] = nativeContext.LoadFunction("SDL_HasGamepad", "SDL3") ) - )(surface, key); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSurfaceColorKey( - Surface* surface, - [NativeTypeName("Uint32 *")] uint* key - ) => DllImport.GetSurfaceColorKey(surface, key); + public static byte HasGamepadRaw() => DllImport.HasGamepadRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSurfaceColorKey( - Ref surface, - [NativeTypeName("Uint32 *")] Ref key - ) - { - fixed (uint* __dsl_key = key) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).GetSurfaceColorKey(__dsl_surface, __dsl_key); - } - } + MaybeBool ISdl.HasJoystick() => (MaybeBool)(byte)((ISdl)this).HasJoystickRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSurfaceColorKey( - Ref surface, - [NativeTypeName("Uint32 *")] Ref key - ) => DllImport.GetSurfaceColorKey(surface, key); + public static MaybeBool HasJoystick() => DllImport.HasJoystick(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => + byte ISdl.HasJoystickRaw() => ( - (delegate* unmanaged)( - _slots[397] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[588] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[397] = nativeContext.LoadFunction("SDL_GetSurfaceColorMod", "SDL3") + : _slots[588] = nativeContext.LoadFunction("SDL_HasJoystick", "SDL3") ) - )(surface, r, g, b); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => DllImport.GetSurfaceColorMod(surface, r, g, b); + public static byte HasJoystickRaw() => DllImport.HasJoystickRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) - { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).GetSurfaceColorMod(__dsl_surface, __dsl_r, __dsl_g, __dsl_b); - } - } + MaybeBool ISdl.HasKeyboard() => (MaybeBool)(byte)((ISdl)this).HasKeyboardRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => DllImport.GetSurfaceColorMod(surface, r, g, b); + public static MaybeBool HasKeyboard() => DllImport.HasKeyboard(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Colorspace ISdl.GetSurfaceColorspace(Surface* surface) => + byte ISdl.HasKeyboardRaw() => ( - (delegate* unmanaged)( - _slots[398] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[589] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[398] = nativeContext.LoadFunction("SDL_GetSurfaceColorspace", "SDL3") + : _slots[589] = nativeContext.LoadFunction("SDL_HasKeyboard", "SDL3") ) - )(surface); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Colorspace GetSurfaceColorspace(Surface* surface) => - DllImport.GetSurfaceColorspace(surface); + public static byte HasKeyboardRaw() => DllImport.HasKeyboardRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Colorspace ISdl.GetSurfaceColorspace(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (Colorspace)((ISdl)this).GetSurfaceColorspace(__dsl_surface); - } - } + MaybeBool ISdl.HasLasx() => (MaybeBool)(byte)((ISdl)this).HasLasxRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Colorspace GetSurfaceColorspace(Ref surface) => - DllImport.GetSurfaceColorspace(surface); + public static MaybeBool HasLasx() => DllImport.HasLasx(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface** ISdl.GetSurfaceImages(Surface* surface, int* count) => + byte ISdl.HasLasxRaw() => ( - (delegate* unmanaged)( - _slots[399] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[590] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[399] = nativeContext.LoadFunction("SDL_GetSurfaceImages", "SDL3") + : _slots[590] = nativeContext.LoadFunction("SDL_HasLASX", "SDL3") ) - )(surface, count); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface** GetSurfaceImages(Surface* surface, int* count) => - DllImport.GetSurfaceImages(surface, count); + public static byte HasLasxRaw() => DllImport.HasLasxRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetSurfaceImages(Ref surface, Ref count) - { - fixed (int* __dsl_count = count) - fixed (Surface* __dsl_surface = surface) - { - return (Surface**)((ISdl)this).GetSurfaceImages(__dsl_surface, __dsl_count); - } - } + MaybeBool ISdl.HasLSX() => (MaybeBool)(byte)((ISdl)this).HasLSXRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetSurfaceImages(Ref surface, Ref count) => - DllImport.GetSurfaceImages(surface, count); + public static MaybeBool HasLSX() => DllImport.HasLSX(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Palette* ISdl.GetSurfacePalette(Surface* surface) => + byte ISdl.HasLSXRaw() => ( - (delegate* unmanaged)( - _slots[400] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[591] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[400] = nativeContext.LoadFunction("SDL_GetSurfacePalette", "SDL3") + : _slots[591] = nativeContext.LoadFunction("SDL_HasLSX", "SDL3") ) - )(surface); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Palette* GetSurfacePalette(Surface* surface) => - DllImport.GetSurfacePalette(surface); + public static byte HasLSXRaw() => DllImport.HasLSXRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetSurfacePalette(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (Palette*)((ISdl)this).GetSurfacePalette(__dsl_surface); - } - } + MaybeBool ISdl.HasMMX() => (MaybeBool)(byte)((ISdl)this).HasMMXRaw(); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetSurfacePalette(Ref surface) => - DllImport.GetSurfacePalette(surface); + public static MaybeBool HasMMX() => DllImport.HasMMX(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetSurfaceProperties(Surface* surface) => + byte ISdl.HasMMXRaw() => ( - (delegate* unmanaged)( - _slots[401] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[592] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[401] = nativeContext.LoadFunction("SDL_GetSurfaceProperties", "SDL3") + : _slots[592] = nativeContext.LoadFunction("SDL_HasMMX", "SDL3") ) - )(surface); + )(); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetSurfaceProperties(Surface* surface) => - DllImport.GetSurfaceProperties(surface); + public static byte HasMMXRaw() => DllImport.HasMMXRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetSurfaceProperties(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - return (uint)((ISdl)this).GetSurfaceProperties(__dsl_surface); - } - } + MaybeBool ISdl.HasMouse() => (MaybeBool)(byte)((ISdl)this).HasMouseRaw(); - [return: NativeTypeName("SDL_PropertiesID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetSurfaceProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetSurfaceProperties(Ref surface) => - DllImport.GetSurfaceProperties(surface); + public static MaybeBool HasMouse() => DllImport.HasMouse(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetSystemRAM() => + byte ISdl.HasMouseRaw() => ( - (delegate* unmanaged)( - _slots[402] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[593] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[402] = nativeContext.LoadFunction("SDL_GetSystemRAM", "SDL3") + : _slots[593] = nativeContext.LoadFunction("SDL_HasMouse", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemRAM")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetSystemRAM() => DllImport.GetSystemRAM(); + public static byte HasMouseRaw() => DllImport.HasMouseRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SystemTheme ISdl.GetSystemTheme() => - ( - (delegate* unmanaged)( - _slots[403] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[403] = nativeContext.LoadFunction("SDL_GetSystemTheme", "SDL3") - ) - )(); + MaybeBool ISdl.HasNeon() => (MaybeBool)(byte)((ISdl)this).HasNeonRaw(); - [NativeFunction("SDL3", EntryPoint = "SDL_GetSystemTheme")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SystemTheme GetSystemTheme() => DllImport.GetSystemTheme(); + public static MaybeBool HasNeon() => DllImport.HasNeon(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => + byte ISdl.HasNeonRaw() => ( - (delegate* unmanaged)( - _slots[404] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[594] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[404] = nativeContext.LoadFunction("SDL_GetTextInputArea", "SDL3") + : _slots[594] = nativeContext.LoadFunction("SDL_HasNEON", "SDL3") ) - )(window, rect, cursor); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextInputArea(WindowHandle window, Rect* rect, int* cursor) => - DllImport.GetTextInputArea(window, rect, cursor); + public static byte HasNeonRaw() => DllImport.HasNeonRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextInputArea(WindowHandle window, Ref rect, Ref cursor) - { - fixed (int* __dsl_cursor = cursor) - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool) - (byte)((ISdl)this).GetTextInputArea(window, __dsl_rect, __dsl_cursor); - } - } + MaybeBool ISdl.HasPrimarySelectionText() => + (MaybeBool)(byte)((ISdl)this).HasPrimarySelectionTextRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextInputArea( - WindowHandle window, - Ref rect, - Ref cursor - ) => DllImport.GetTextInputArea(window, rect, cursor); + public static MaybeBool HasPrimarySelectionText() => DllImport.HasPrimarySelectionText(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8 *")] byte* alpha) => + byte ISdl.HasPrimarySelectionTextRaw() => ( - (delegate* unmanaged)( - _slots[405] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[595] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[405] = nativeContext.LoadFunction("SDL_GetTextureAlphaMod", "SDL3") + : _slots[595] = nativeContext.LoadFunction( + "SDL_HasPrimarySelectionText", + "SDL3" + ) ) - )(texture, alpha); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureAlphaMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* alpha - ) => DllImport.GetTextureAlphaMod(texture, alpha); + public static byte HasPrimarySelectionTextRaw() => DllImport.HasPrimarySelectionTextRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref alpha + byte ISdl.HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => + ( + (delegate* unmanaged)( + _slots[596] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[596] = nativeContext.LoadFunction("SDL_HasProperty", "SDL3") + ) + )(props, name); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.HasProperty(props, name); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name ) { - fixed (byte* __dsl_alpha = alpha) - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool) - (byte)((ISdl)this).GetTextureAlphaMod(__dsl_texture, __dsl_alpha); + return (MaybeBool)(byte)((ISdl)this).HasProperty(props, __dsl_name); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref alpha - ) => DllImport.GetTextureAlphaMod(texture, alpha); + public static MaybeBool HasProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name + ) => DllImport.HasProperty(props, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureAlphaModFloat(Texture* texture, float* alpha) => + byte ISdl.HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B + ) => ( - (delegate* unmanaged)( - _slots[406] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[597] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[406] = nativeContext.LoadFunction( - "SDL_GetTextureAlphaModFloat", - "SDL3" - ) + : _slots[597] = nativeContext.LoadFunction("SDL_HasRectIntersection", "SDL3") ) - )(texture, alpha); + )(A, B); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureAlphaModFloat(Texture* texture, float* alpha) => - DllImport.GetTextureAlphaModFloat(texture, alpha); + public static byte HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Rect* A, + [NativeTypeName("const SDL_Rect *")] Rect* B + ) => DllImport.HasRectIntersection(A, B); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureAlphaModFloat(Ref texture, Ref alpha) + MaybeBool ISdl.HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B + ) { - fixed (float* __dsl_alpha = alpha) - fixed (Texture* __dsl_texture = texture) + fixed (Rect* __dsl_B = B) + fixed (Rect* __dsl_A = A) { - return (MaybeBool) - (byte)((ISdl)this).GetTextureAlphaModFloat(__dsl_texture, __dsl_alpha); + return (MaybeBool)(byte)((ISdl)this).HasRectIntersection(__dsl_A, __dsl_B); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureAlphaModFloat(Ref texture, Ref alpha) => - DllImport.GetTextureAlphaModFloat(texture, alpha); + public static MaybeBool HasRectIntersection( + [NativeTypeName("const SDL_Rect *")] Ref A, + [NativeTypeName("const SDL_Rect *")] Ref B + ) => DllImport.HasRectIntersection(A, B); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode + byte ISdl.HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B ) => ( - (delegate* unmanaged)( - _slots[407] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[598] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[407] = nativeContext.LoadFunction("SDL_GetTextureBlendMode", "SDL3") + : _slots[598] = nativeContext.LoadFunction( + "SDL_HasRectIntersectionFloat", + "SDL3" + ) ) - )(texture, blendMode); + )(A, B); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode *")] BlendMode* blendMode - ) => DllImport.GetTextureBlendMode(texture, blendMode); + public static byte HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] FRect* A, + [NativeTypeName("const SDL_FRect *")] FRect* B + ) => DllImport.HasRectIntersectionFloat(A, B); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode + MaybeBool ISdl.HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B ) { - fixed (BlendMode* __dsl_blendMode = blendMode) - fixed (Texture* __dsl_texture = texture) + fixed (FRect* __dsl_B = B) + fixed (FRect* __dsl_A = A) { - return (MaybeBool) - (byte)((ISdl)this).GetTextureBlendMode(__dsl_texture, __dsl_blendMode); + return (MaybeBool)(byte)((ISdl)this).HasRectIntersectionFloat(__dsl_A, __dsl_B); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode *")] Ref blendMode - ) => DllImport.GetTextureBlendMode(texture, blendMode); + public static MaybeBool HasRectIntersectionFloat( + [NativeTypeName("const SDL_FRect *")] Ref A, + [NativeTypeName("const SDL_FRect *")] Ref B + ) => DllImport.HasRectIntersectionFloat(A, B); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => + MaybeBool ISdl.HasScreenKeyboardSupport() => + (MaybeBool)(byte)((ISdl)this).HasScreenKeyboardSupportRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool HasScreenKeyboardSupport() => + DllImport.HasScreenKeyboardSupport(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasScreenKeyboardSupportRaw() => ( - (delegate* unmanaged)( - _slots[408] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[599] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[408] = nativeContext.LoadFunction("SDL_GetTextureColorMod", "SDL3") + : _slots[599] = nativeContext.LoadFunction( + "SDL_HasScreenKeyboardSupport", + "SDL3" + ) ) - )(texture, r, g, b); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b - ) => DllImport.GetTextureColorMod(texture, r, g, b); + public static byte HasScreenKeyboardSupportRaw() => DllImport.HasScreenKeyboardSupportRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) - { - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)((ISdl)this).GetTextureColorMod(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); - } - } + MaybeBool ISdl.HasSSE() => (MaybeBool)(byte)((ISdl)this).HasSSERaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b - ) => DllImport.GetTextureColorMod(texture, r, g, b); + public static MaybeBool HasSSE() => DllImport.HasSSE(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => + MaybeBool ISdl.HasSSE2() => (MaybeBool)(byte)((ISdl)this).HasSSE2Raw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool HasSSE2() => DllImport.HasSSE2(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.HasSSE2Raw() => ( - (delegate* unmanaged)( - _slots[409] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[601] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[409] = nativeContext.LoadFunction( - "SDL_GetTextureColorModFloat", - "SDL3" - ) + : _slots[601] = nativeContext.LoadFunction("SDL_HasSSE2", "SDL3") ) - )(texture, r, g, b); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureColorModFloat(Texture* texture, float* r, float* g, float* b) => - DllImport.GetTextureColorModFloat(texture, r, g, b); + public static byte HasSSE2Raw() => DllImport.HasSSE2Raw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureColorModFloat( - Ref texture, - Ref r, - Ref g, - Ref b - ) - { - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte) - ((ISdl)this).GetTextureColorModFloat(__dsl_texture, __dsl_r, __dsl_g, __dsl_b); - } - } + MaybeBool ISdl.HasSSE3() => (MaybeBool)(byte)((ISdl)this).HasSSE3Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureColorModFloat( - Ref texture, - Ref r, - Ref g, - Ref b - ) => DllImport.GetTextureColorModFloat(texture, r, g, b); + public static MaybeBool HasSSE3() => DllImport.HasSSE3(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetTextureProperties(Texture* texture) => + byte ISdl.HasSSE3Raw() => ( - (delegate* unmanaged)( - _slots[410] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[602] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[410] = nativeContext.LoadFunction("SDL_GetTextureProperties", "SDL3") + : _slots[602] = nativeContext.LoadFunction("SDL_HasSSE3", "SDL3") ) - )(texture); + )(); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetTextureProperties(Texture* texture) => - DllImport.GetTextureProperties(texture); + public static byte HasSSE3Raw() => DllImport.HasSSE3Raw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetTextureProperties(Ref texture) - { - fixed (Texture* __dsl_texture = texture) - { - return (uint)((ISdl)this).GetTextureProperties(__dsl_texture); - } - } + MaybeBool ISdl.HasSSE41() => (MaybeBool)(byte)((ISdl)this).HasSSE41Raw(); - [return: NativeTypeName("SDL_PropertiesID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetTextureProperties(Ref texture) => - DllImport.GetTextureProperties(texture); + public static MaybeBool HasSSE41() => DllImport.HasSSE41(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => + byte ISdl.HasSSE41Raw() => ( - (delegate* unmanaged)( - _slots[411] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[603] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[411] = nativeContext.LoadFunction("SDL_GetTextureScaleMode", "SDL3") + : _slots[603] = nativeContext.LoadFunction("SDL_HasSSE41", "SDL3") ) - )(texture, scaleMode); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureScaleMode(Texture* texture, ScaleMode* scaleMode) => - DllImport.GetTextureScaleMode(texture, scaleMode); + public static byte HasSSE41Raw() => DllImport.HasSSE41Raw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureScaleMode(Ref texture, Ref scaleMode) - { - fixed (ScaleMode* __dsl_scaleMode = scaleMode) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)((ISdl)this).GetTextureScaleMode(__dsl_texture, __dsl_scaleMode); - } - } + MaybeBool ISdl.HasSSE42() => (MaybeBool)(byte)((ISdl)this).HasSSE42Raw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureScaleMode( - Ref texture, - Ref scaleMode - ) => DllImport.GetTextureScaleMode(texture, scaleMode); + public static MaybeBool HasSSE42() => DllImport.HasSSE42(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetTextureSize(Texture* texture, float* w, float* h) => + byte ISdl.HasSSE42Raw() => ( - (delegate* unmanaged)( - _slots[412] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[604] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[412] = nativeContext.LoadFunction("SDL_GetTextureSize", "SDL3") + : _slots[604] = nativeContext.LoadFunction("SDL_HasSSE42", "SDL3") ) - )(texture, w, h); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetTextureSize(Texture* texture, float* w, float* h) => - DllImport.GetTextureSize(texture, w, h); + public static byte HasSSE42Raw() => DllImport.HasSSE42Raw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetTextureSize(Ref texture, Ref w, Ref h) - { - fixed (float* __dsl_h = h) - fixed (float* __dsl_w = w) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)((ISdl)this).GetTextureSize(__dsl_texture, __dsl_w, __dsl_h); - } - } + byte ISdl.HasSSERaw() => + ( + (delegate* unmanaged)( + _slots[600] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[600] = nativeContext.LoadFunction("SDL_HasSSE", "SDL3") + ) + )(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTextureSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetTextureSize( - Ref texture, - Ref w, - Ref h - ) => DllImport.GetTextureSize(texture, w, h); + public static byte HasSSERaw() => DllImport.HasSSERaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetThreadID(ThreadHandle thread) => + void ISdl.HidBleScan([NativeTypeName("bool")] byte active) => ( - (delegate* unmanaged)( - _slots[413] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[605] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[413] = nativeContext.LoadFunction("SDL_GetThreadID", "SDL3") + : _slots[605] = nativeContext.LoadFunction("SDL_hid_ble_scan", "SDL3") ) - )(thread); + )(active); - [return: NativeTypeName("SDL_ThreadID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadID")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetThreadID(ThreadHandle thread) => DllImport.GetThreadID(thread); + public static void HidBleScan([NativeTypeName("bool")] byte active) => + DllImport.HidBleScan(active); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetThreadName(ThreadHandle thread) => - (sbyte*)((ISdl)this).GetThreadNameRaw(thread); + void ISdl.HidBleScan([NativeTypeName("bool")] MaybeBool active) => + ((ISdl)this).HidBleScan((byte)active); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetThreadName(ThreadHandle thread) => DllImport.GetThreadName(thread); + public static void HidBleScan([NativeTypeName("bool")] MaybeBool active) => + DllImport.HidBleScan(active); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetThreadNameRaw(ThreadHandle thread) => + int ISdl.HidClose(HidDeviceHandle dev) => ( - (delegate* unmanaged)( - _slots[414] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[606] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[414] = nativeContext.LoadFunction("SDL_GetThreadName", "SDL3") + : _slots[606] = nativeContext.LoadFunction("SDL_hid_close", "SDL3") ) - )(thread); + )(dev); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetThreadName")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetThreadNameRaw(ThreadHandle thread) => - DllImport.GetThreadNameRaw(thread); + public static int HidClose(HidDeviceHandle dev) => DllImport.HidClose(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetTicks() => + uint ISdl.HidDeviceChangeCount() => ( - (delegate* unmanaged)( - _slots[415] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[607] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[415] = nativeContext.LoadFunction("SDL_GetTicks", "SDL3") + : _slots[607] = nativeContext.LoadFunction( + "SDL_hid_device_change_count", + "SDL3" + ) ) )(); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicks")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetTicks() => DllImport.GetTicks(); + public static uint HidDeviceChangeCount() => DllImport.HidDeviceChangeCount(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetTicksNS() => + Ptr ISdl.HidEnumerate( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => (HidDeviceInfo*)((ISdl)this).HidEnumerateRaw(vendor_id, product_id); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr HidEnumerate( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => DllImport.HidEnumerate(vendor_id, product_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + HidDeviceInfo* ISdl.HidEnumerateRaw( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => ( - (delegate* unmanaged)( - _slots[416] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[608] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[608] = nativeContext.LoadFunction("SDL_hid_enumerate", "SDL3") + ) + )(vendor_id, product_id); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static HidDeviceInfo* HidEnumerateRaw( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id + ) => DllImport.HidEnumerateRaw(vendor_id, product_id); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.HidExit() => + ( + (delegate* unmanaged)( + _slots[609] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[416] = nativeContext.LoadFunction("SDL_GetTicksNS", "SDL3") + : _slots[609] = nativeContext.LoadFunction("SDL_hid_exit", "SDL3") ) )(); - [return: NativeTypeName("Uint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTicksNS")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetTicksNS() => DllImport.GetTicksNS(); + public static int HidExit() => DllImport.HidExit(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => + void ISdl.HidFreeEnumeration(HidDeviceInfo* devs) => ( - (delegate* unmanaged)( - _slots[417] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[610] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[417] = nativeContext.LoadFunction("SDL_GetTLS", "SDL3") + : _slots[610] = nativeContext.LoadFunction("SDL_hid_free_enumeration", "SDL3") ) - )(id); + )(devs); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetTLS([NativeTypeName("SDL_TLSID *")] AtomicInt* id) => - DllImport.GetTLS(id); + public static void HidFreeEnumeration(HidDeviceInfo* devs) => + DllImport.HidFreeEnumeration(devs); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) + void ISdl.HidFreeEnumeration(Ref devs) { - fixed (AtomicInt* __dsl_id = id) + fixed (HidDeviceInfo* __dsl_devs = devs) { - return (void*)((ISdl)this).GetTLS(__dsl_id); + ((ISdl)this).HidFreeEnumeration(__dsl_devs); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetTLS([NativeTypeName("SDL_TLSID *")] Ref id) => - DllImport.GetTLS(id); + public static void HidFreeEnumeration(Ref devs) => + DllImport.HidFreeEnumeration(devs); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => - (sbyte*)((ISdl)this).GetTouchDeviceNameRaw(touchID); + Ptr ISdl.HidGetDeviceInfo(HidDeviceHandle dev) => + (HidDeviceInfo*)((ISdl)this).HidGetDeviceInfoRaw(dev); - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetTouchDeviceName([NativeTypeName("SDL_TouchID")] ulong touchID) => - DllImport.GetTouchDeviceName(touchID); + public static Ptr HidGetDeviceInfo(HidDeviceHandle dev) => + DllImport.HidGetDeviceInfo(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => + HidDeviceInfo* ISdl.HidGetDeviceInfoRaw(HidDeviceHandle dev) => ( - (delegate* unmanaged)( - _slots[418] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[611] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[418] = nativeContext.LoadFunction("SDL_GetTouchDeviceName", "SDL3") + : _slots[611] = nativeContext.LoadFunction("SDL_hid_get_device_info", "SDL3") ) - )(touchID); + )(dev); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceName")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetTouchDeviceNameRaw([NativeTypeName("SDL_TouchID")] ulong touchID) => - DllImport.GetTouchDeviceNameRaw(touchID); + public static HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => + DllImport.HidGetDeviceInfoRaw(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong* ISdl.GetTouchDevices(int* count) => + int ISdl.HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => ( - (delegate* unmanaged)( - _slots[419] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[612] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[419] = nativeContext.LoadFunction("SDL_GetTouchDevices", "SDL3") + : _slots[612] = nativeContext.LoadFunction("SDL_hid_get_feature_report", "SDL3") ) - )(count); + )(dev, data, length); - [return: NativeTypeName("SDL_TouchID *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong* GetTouchDevices(int* count) => DllImport.GetTouchDevices(count); + public static int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidGetFeatureReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetTouchDevices(Ref count) + int ISdl.HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) { - fixed (int* __dsl_count = count) + fixed (byte* __dsl_data = data) { - return (ulong*)((ISdl)this).GetTouchDevices(__dsl_count); + return (int)((ISdl)this).HidGetFeatureReport(dev, __dsl_data, length); } } - [return: NativeTypeName("SDL_TouchID *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDevices")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetTouchDevices(Ref count) => DllImport.GetTouchDevices(count); + public static int HidGetFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidGetFeatureReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - TouchDeviceType ISdl.GetTouchDeviceType([NativeTypeName("SDL_TouchID")] ulong touchID) => + int ISdl.HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => ( - (delegate* unmanaged)( - _slots[420] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[613] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[420] = nativeContext.LoadFunction("SDL_GetTouchDeviceType", "SDL3") + : _slots[613] = nativeContext.LoadFunction("SDL_hid_get_indexed_string", "SDL3") ) - )(touchID); + )(dev, string_index, @string, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchDeviceType")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static TouchDeviceType GetTouchDeviceType( - [NativeTypeName("SDL_TouchID")] ulong touchID - ) => DllImport.GetTouchDeviceType(touchID); + public static int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetIndexedString(dev, string_index, @string, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)((ISdl)this).HidGetIndexedString(dev, string_index, __dsl_string, maxlen); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int HidGetIndexedString( + HidDeviceHandle dev, + int string_index, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetIndexedString(dev, string_index, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Finger** ISdl.GetTouchFingers([NativeTypeName("SDL_TouchID")] ulong touchID, int* count) => + int ISdl.HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => ( - (delegate* unmanaged)( - _slots[421] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[614] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[421] = nativeContext.LoadFunction("SDL_GetTouchFingers", "SDL3") + : _slots[614] = nativeContext.LoadFunction("SDL_hid_get_input_report", "SDL3") ) - )(touchID, count); + )(dev, data, length); - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Finger** GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - int* count - ) => DllImport.GetTouchFingers(touchID, count); + public static int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidGetInputReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - Ref count + int ISdl.HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length ) { - fixed (int* __dsl_count = count) + fixed (byte* __dsl_data = data) { - return (Finger**)((ISdl)this).GetTouchFingers(touchID, __dsl_count); + return (int)((ISdl)this).HidGetInputReport(dev, __dsl_data, length); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetTouchFingers")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GetTouchFingers( - [NativeTypeName("SDL_TouchID")] ulong touchID, - Ref count - ) => DllImport.GetTouchFingers(touchID, count); + public static int HidGetInputReport( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidGetInputReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetUserFolder(Folder folder) => (sbyte*)((ISdl)this).GetUserFolderRaw(folder); + int ISdl.HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[615] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[615] = nativeContext.LoadFunction( + "SDL_hid_get_manufacturer_string", + "SDL3" + ) + ) + )(dev, @string, maxlen); - [return: NativeTypeName("const char *")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetUserFolder(Folder folder) => DllImport.GetUserFolder(folder); + public static int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetManufacturerString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetUserFolderRaw(Folder folder) => - ( - (delegate* unmanaged)( - _slots[422] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[422] = nativeContext.LoadFunction("SDL_GetUserFolder", "SDL3") - ) - )(folder); + int ISdl.HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)((ISdl)this).HidGetManufacturerString(dev, __dsl_string, maxlen); + } + } - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetUserFolder")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetUserFolderRaw(Folder folder) => DllImport.GetUserFolderRaw(folder); + public static int HidGetManufacturerString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetManufacturerString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.GetVersion() => + int ISdl.HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => ( - (delegate* unmanaged)( - _slots[423] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[616] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[423] = nativeContext.LoadFunction("SDL_GetVersion", "SDL3") + : _slots[616] = nativeContext.LoadFunction("SDL_hid_get_product_string", "SDL3") ) - )(); + )(dev, @string, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_GetVersion")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int GetVersion() => DllImport.GetVersion(); + public static int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetProductString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetVideoDriver(int index) => (sbyte*)((ISdl)this).GetVideoDriverRaw(index); + int ISdl.HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_string = @string) + { + return (int)((ISdl)this).HidGetProductString(dev, __dsl_string, maxlen); + } + } - [return: NativeTypeName("const char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetVideoDriver(int index) => DllImport.GetVideoDriver(index); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetVideoDriverRaw(int index) => - ( - (delegate* unmanaged)( - _slots[424] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[424] = nativeContext.LoadFunction("SDL_GetVideoDriver", "SDL3") - ) - )(index); - - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetVideoDriver")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetVideoDriverRaw(int index) => DllImport.GetVideoDriverRaw(index); + public static int HidGetProductString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetProductString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowAspectRatio(WindowHandle window, float* min_aspect, float* max_aspect) => + int ISdl.HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* buf, + [NativeTypeName("size_t")] nuint buf_size + ) => ( - (delegate* unmanaged)( - _slots[425] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[617] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[425] = nativeContext.LoadFunction("SDL_GetWindowAspectRatio", "SDL3") + : _slots[617] = nativeContext.LoadFunction( + "SDL_hid_get_report_descriptor", + "SDL3" + ) ) - )(window, min_aspect, max_aspect); + )(dev, buf, buf_size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowAspectRatio( - WindowHandle window, - float* min_aspect, - float* max_aspect - ) => DllImport.GetWindowAspectRatio(window, min_aspect, max_aspect); + public static int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* buf, + [NativeTypeName("size_t")] nuint buf_size + ) => DllImport.HidGetReportDescriptor(dev, buf, buf_size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowAspectRatio( - WindowHandle window, - Ref min_aspect, - Ref max_aspect + int ISdl.HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref buf, + [NativeTypeName("size_t")] nuint buf_size ) { - fixed (float* __dsl_max_aspect = max_aspect) - fixed (float* __dsl_min_aspect = min_aspect) + fixed (byte* __dsl_buf = buf) { - return (MaybeBool) - (byte)((ISdl)this).GetWindowAspectRatio(window, __dsl_min_aspect, __dsl_max_aspect); + return (int)((ISdl)this).HidGetReportDescriptor(dev, __dsl_buf, buf_size); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowAspectRatio( - WindowHandle window, - Ref min_aspect, - Ref max_aspect - ) => DllImport.GetWindowAspectRatio(window, min_aspect, max_aspect); + public static int HidGetReportDescriptor( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref buf, + [NativeTypeName("size_t")] nuint buf_size + ) => DllImport.HidGetReportDescriptor(dev, buf, buf_size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowBordersSize( - WindowHandle window, - int* top, - int* left, - int* bottom, - int* right + int ISdl.HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen ) => ( - (delegate* unmanaged)( - _slots[426] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[618] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[426] = nativeContext.LoadFunction("SDL_GetWindowBordersSize", "SDL3") + : _slots[618] = nativeContext.LoadFunction( + "SDL_hid_get_serial_number_string", + "SDL3" + ) ) - )(window, top, left, bottom, right); + )(dev, @string, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowBordersSize( - WindowHandle window, - int* top, - int* left, - int* bottom, - int* right - ) => DllImport.GetWindowBordersSize(window, top, left, bottom, right); + public static int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] uint* @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetSerialNumberString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowBordersSize( - WindowHandle window, - Ref top, - Ref left, - Ref bottom, - Ref right + int ISdl.HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (int* __dsl_right = right) - fixed (int* __dsl_bottom = bottom) - fixed (int* __dsl_left = left) - fixed (int* __dsl_top = top) + fixed (uint* __dsl_string = @string) { - return (MaybeBool) - (byte) - ((ISdl)this).GetWindowBordersSize( - window, - __dsl_top, - __dsl_left, - __dsl_bottom, - __dsl_right - ); + return (int)((ISdl)this).HidGetSerialNumberString(dev, __dsl_string, maxlen); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowBordersSize")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowBordersSize( - WindowHandle window, - Ref top, - Ref left, - Ref bottom, - Ref right - ) => DllImport.GetWindowBordersSize(window, top, left, bottom, right); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetWindowDisplayScale(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[427] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[427] = nativeContext.LoadFunction("SDL_GetWindowDisplayScale", "SDL3") - ) - )(window); - - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowDisplayScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetWindowDisplayScale(WindowHandle window) => - DllImport.GetWindowDisplayScale(window); + public static int HidGetSerialNumberString( + HidDeviceHandle dev, + [NativeTypeName("wchar_t *")] Ref @string, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.HidGetSerialNumberString(dev, @string, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - ulong ISdl.GetWindowFlags(WindowHandle window) => + int ISdl.HidInit() => ( - (delegate* unmanaged)( - _slots[428] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[619] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[428] = nativeContext.LoadFunction("SDL_GetWindowFlags", "SDL3") + : _slots[619] = nativeContext.LoadFunction("SDL_hid_init", "SDL3") ) - )(window); + )(); - [return: NativeTypeName("SDL_WindowFlags")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFlags")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static ulong GetWindowFlags(WindowHandle window) => DllImport.GetWindowFlags(window); + public static int HidInit() => DllImport.HidInit(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetWindowFromEvent([NativeTypeName("const SDL_Event *")] Event* @event) => + HidDeviceHandle ISdl.HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] uint* serial_number + ) => ( - (delegate* unmanaged)( - _slots[429] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[620] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[429] = nativeContext.LoadFunction("SDL_GetWindowFromEvent", "SDL3") + : _slots[620] = nativeContext.LoadFunction("SDL_hid_open", "SDL3") ) - )(@event); + )(vendor_id, product_id, serial_number); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Event* @event - ) => DllImport.GetWindowFromEvent(@event); + public static HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] uint* serial_number + ) => DllImport.HidOpen(vendor_id, product_id, serial_number); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetWindowFromEvent([NativeTypeName("const SDL_Event *")] Ref @event) + HidDeviceHandle ISdl.HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] Ref serial_number + ) { - fixed (Event* __dsl_event = @event) + fixed (uint* __dsl_serial_number = serial_number) { - return (WindowHandle)((ISdl)this).GetWindowFromEvent(__dsl_event); + return (HidDeviceHandle) + ((ISdl)this).HidOpen(vendor_id, product_id, __dsl_serial_number); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetWindowFromEvent( - [NativeTypeName("const SDL_Event *")] Ref @event - ) => DllImport.GetWindowFromEvent(@event); + public static HidDeviceHandle HidOpen( + [NativeTypeName("unsigned short")] ushort vendor_id, + [NativeTypeName("unsigned short")] ushort product_id, + [NativeTypeName("const wchar_t *")] Ref serial_number + ) => DllImport.HidOpen(vendor_id, product_id, serial_number); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => + HidDeviceHandle ISdl.HidOpenPath([NativeTypeName("const char *")] sbyte* path) => ( - (delegate* unmanaged)( - _slots[430] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[621] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[430] = nativeContext.LoadFunction("SDL_GetWindowFromID", "SDL3") + : _slots[621] = nativeContext.LoadFunction("SDL_hid_open_path", "SDL3") ) - )(id); + )(path); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFromID")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetWindowFromID([NativeTypeName("SDL_WindowID")] uint id) => - DllImport.GetWindowFromID(id); + public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => + DllImport.HidOpenPath(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindowFullscreenMode(WindowHandle window) => - (DisplayMode*)((ISdl)this).GetWindowFullscreenModeRaw(window); + HidDeviceHandle ISdl.HidOpenPath([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (HidDeviceHandle)((ISdl)this).HidOpenPath(__dsl_path); + } + } - [return: NativeTypeName("const SDL_DisplayMode *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindowFullscreenMode(WindowHandle window) => - DllImport.GetWindowFullscreenMode(window); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - DisplayMode* ISdl.GetWindowFullscreenModeRaw(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[431] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[431] = nativeContext.LoadFunction( - "SDL_GetWindowFullscreenMode", - "SDL3" - ) - ) - )(window); - - [return: NativeTypeName("const SDL_DisplayMode *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static DisplayMode* GetWindowFullscreenModeRaw(WindowHandle window) => - DllImport.GetWindowFullscreenModeRaw(window); + public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) => + DllImport.HidOpenPath(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.GetWindowICCProfile(WindowHandle window, [NativeTypeName("size_t *")] nuint* size) => + int ISdl.HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => ( - (delegate* unmanaged)( - _slots[432] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[622] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[432] = nativeContext.LoadFunction("SDL_GetWindowICCProfile", "SDL3") + : _slots[622] = nativeContext.LoadFunction("SDL_hid_read", "SDL3") ) - )(window, size); + )(dev, data, length); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* GetWindowICCProfile( - WindowHandle window, - [NativeTypeName("size_t *")] nuint* size - ) => DllImport.GetWindowICCProfile(window, size); + public static int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidRead(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindowICCProfile(WindowHandle window, [NativeTypeName("size_t *")] Ref size) + int ISdl.HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) { - fixed (nuint* __dsl_size = size) + fixed (byte* __dsl_data = data) { - return (void*)((ISdl)this).GetWindowICCProfile(window, __dsl_size); + return (int)((ISdl)this).HidRead(dev, __dsl_data, length); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowICCProfile")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindowICCProfile( - WindowHandle window, - [NativeTypeName("size_t *")] Ref size - ) => DllImport.GetWindowICCProfile(window, size); + public static int HidRead( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidRead(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetWindowID(WindowHandle window) => + int ISdl.HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => ( - (delegate* unmanaged)( - _slots[433] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[623] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[433] = nativeContext.LoadFunction("SDL_GetWindowID", "SDL3") + : _slots[623] = nativeContext.LoadFunction("SDL_hid_read_timeout", "SDL3") ) - )(window); + )(dev, data, length, milliseconds); - [return: NativeTypeName("SDL_WindowID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowID")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetWindowID(WindowHandle window) => DllImport.GetWindowID(window); + public static int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => DllImport.HidReadTimeout(dev, data, length, milliseconds); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowKeyboardGrab(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).GetWindowKeyboardGrabRaw(window); + int ISdl.HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) + { + fixed (byte* __dsl_data = data) + { + return (int)((ISdl)this).HidReadTimeout(dev, __dsl_data, length, milliseconds); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowKeyboardGrab(WindowHandle window) => - DllImport.GetWindowKeyboardGrab(window); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowKeyboardGrabRaw(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[434] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[434] = nativeContext.LoadFunction("SDL_GetWindowKeyboardGrab", "SDL3") - ) - )(window); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowKeyboardGrabRaw(WindowHandle window) => - DllImport.GetWindowKeyboardGrabRaw(window); + public static int HidReadTimeout( + HidDeviceHandle dev, + [NativeTypeName("unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length, + int milliseconds + ) => DllImport.HidReadTimeout(dev, data, length, milliseconds); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowMaximumSize(WindowHandle window, int* w, int* h) => + int ISdl.HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => ( - (delegate* unmanaged)( - _slots[435] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[624] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[435] = nativeContext.LoadFunction("SDL_GetWindowMaximumSize", "SDL3") + : _slots[624] = nativeContext.LoadFunction( + "SDL_hid_send_feature_report", + "SDL3" + ) ) - )(window, w, h); + )(dev, data, length); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowMaximumSize(WindowHandle window, int* w, int* h) => - DllImport.GetWindowMaximumSize(window, w, h); + public static int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidSendFeatureReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowMaximumSize(WindowHandle window, Ref w, Ref h) + int ISdl.HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (byte* __dsl_data = data) { - return (MaybeBool) - (byte)((ISdl)this).GetWindowMaximumSize(window, __dsl_w, __dsl_h); + return (int)((ISdl)this).HidSendFeatureReport(dev, __dsl_data, length); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowMaximumSize( - WindowHandle window, - Ref w, - Ref h - ) => DllImport.GetWindowMaximumSize(window, w, h); + public static int HidSendFeatureReport( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidSendFeatureReport(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowMinimumSize(WindowHandle window, int* w, int* h) => + int ISdl.HidSetNonblocking(HidDeviceHandle dev, int nonblock) => ( - (delegate* unmanaged)( - _slots[436] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[625] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[436] = nativeContext.LoadFunction("SDL_GetWindowMinimumSize", "SDL3") + : _slots[625] = nativeContext.LoadFunction("SDL_hid_set_nonblocking", "SDL3") ) - )(window, w, h); + )(dev, nonblock); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowMinimumSize(WindowHandle window, int* w, int* h) => - DllImport.GetWindowMinimumSize(window, w, h); + public static int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => + DllImport.HidSetNonblocking(dev, nonblock); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowMinimumSize(WindowHandle window, Ref w, Ref h) + int ISdl.HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => + ( + (delegate* unmanaged)( + _slots[626] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[626] = nativeContext.LoadFunction("SDL_hid_write", "SDL3") + ) + )(dev, data, length); + + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] byte* data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidWrite(dev, data, length); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (byte* __dsl_data = data) { - return (MaybeBool) - (byte)((ISdl)this).GetWindowMinimumSize(window, __dsl_w, __dsl_h); + return (int)((ISdl)this).HidWrite(dev, __dsl_data, length); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowMinimumSize( - WindowHandle window, - Ref w, - Ref h - ) => DllImport.GetWindowMinimumSize(window, w, h); + public static int HidWrite( + HidDeviceHandle dev, + [NativeTypeName("const unsigned char *")] Ref data, + [NativeTypeName("size_t")] nuint length + ) => DllImport.HidWrite(dev, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowMouseGrab(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).GetWindowMouseGrabRaw(window); + MaybeBool ISdl.HideCursor() => (MaybeBool)(byte)((ISdl)this).HideCursorRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowMouseGrab(WindowHandle window) => - DllImport.GetWindowMouseGrab(window); + public static MaybeBool HideCursor() => DllImport.HideCursor(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowMouseGrabRaw(WindowHandle window) => + byte ISdl.HideCursorRaw() => ( - (delegate* unmanaged)( - _slots[437] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[627] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[437] = nativeContext.LoadFunction("SDL_GetWindowMouseGrab", "SDL3") + : _slots[627] = nativeContext.LoadFunction("SDL_HideCursor", "SDL3") ) - )(window); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowMouseGrabRaw(WindowHandle window) => - DllImport.GetWindowMouseGrabRaw(window); + public static byte HideCursorRaw() => DllImport.HideCursorRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindowMouseRect(WindowHandle window) => - (Rect*)((ISdl)this).GetWindowMouseRectRaw(window); + MaybeBool ISdl.HideWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).HideWindowRaw(window); - [return: NativeTypeName("const SDL_Rect *")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindowMouseRect(WindowHandle window) => - DllImport.GetWindowMouseRect(window); + public static MaybeBool HideWindow(WindowHandle window) => DllImport.HideWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Rect* ISdl.GetWindowMouseRectRaw(WindowHandle window) => + byte ISdl.HideWindowRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[438] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[628] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[438] = nativeContext.LoadFunction("SDL_GetWindowMouseRect", "SDL3") + : _slots[628] = nativeContext.LoadFunction("SDL_HideWindow", "SDL3") ) )(window); - [return: NativeTypeName("const SDL_Rect *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowMouseRect")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Rect* GetWindowMouseRectRaw(WindowHandle window) => - DllImport.GetWindowMouseRectRaw(window); + public static byte HideWindowRaw(WindowHandle window) => DllImport.HideWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetWindowOpacity(WindowHandle window) => + nuint ISdl.Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ) => ( - (delegate* unmanaged)( - _slots[439] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[629] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[439] = nativeContext.LoadFunction("SDL_GetWindowOpacity", "SDL3") + : _slots[629] = nativeContext.LoadFunction("SDL_iconv", "SDL3") ) - )(window); + )(cd, inbuf, inbytesleft, outbuf, outbytesleft); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowOpacity")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] sbyte** inbuf, + [NativeTypeName("size_t *")] nuint* inbytesleft, + [NativeTypeName("char **")] sbyte** outbuf, + [NativeTypeName("size_t *")] nuint* outbytesleft + ) => DllImport.Iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ) + { + fixed (nuint* __dsl_outbytesleft = outbytesleft) + fixed (sbyte** __dsl_outbuf = outbuf) + fixed (nuint* __dsl_inbytesleft = inbytesleft) + fixed (sbyte** __dsl_inbuf = inbuf) + { + return (nuint) + ((ISdl)this).Iconv( + cd, + __dsl_inbuf, + __dsl_inbytesleft, + __dsl_outbuf, + __dsl_outbytesleft + ); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetWindowOpacity(WindowHandle window) => DllImport.GetWindowOpacity(window); + public static nuint Iconv( + [NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd, + [NativeTypeName("const char **")] Ref2D inbuf, + [NativeTypeName("size_t *")] Ref inbytesleft, + [NativeTypeName("char **")] Ref2D outbuf, + [NativeTypeName("size_t *")] Ref outbytesleft + ) => DllImport.Iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GetWindowParent(WindowHandle window) => + int ISdl.IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd) => ( - (delegate* unmanaged)( - _slots[440] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[630] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[440] = nativeContext.LoadFunction("SDL_GetWindowParent", "SDL3") + : _slots[630] = nativeContext.LoadFunction("SDL_iconv_close", "SDL3") ) - )(window); + )(cd); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_close")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GetWindowParent(WindowHandle window) => - DllImport.GetWindowParent(window); + public static int IconvClose([NativeTypeName("SDL_iconv_t")] IconvDataTHandle cd) => + DllImport.IconvClose(cd); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - float ISdl.GetWindowPixelDensity(WindowHandle window) => + IconvDataTHandle ISdl.IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ) => ( - (delegate* unmanaged)( - _slots[441] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[631] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[441] = nativeContext.LoadFunction("SDL_GetWindowPixelDensity", "SDL3") + : _slots[631] = nativeContext.LoadFunction("SDL_iconv_open", "SDL3") ) - )(window); + )(tocode, fromcode); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelDensity")] + [return: NativeTypeName("SDL_iconv_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static float GetWindowPixelDensity(WindowHandle window) => - DllImport.GetWindowPixelDensity(window); + public static IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode + ) => DllImport.IconvOpen(tocode, fromcode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - PixelFormat ISdl.GetWindowPixelFormat(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[442] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[442] = nativeContext.LoadFunction("SDL_GetWindowPixelFormat", "SDL3") - ) - )(window); + IconvDataTHandle ISdl.IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ) + { + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) + { + return (IconvDataTHandle)((ISdl)this).IconvOpen(__dsl_tocode, __dsl_fromcode); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPixelFormat")] + [return: NativeTypeName("SDL_iconv_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_open")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static PixelFormat GetWindowPixelFormat(WindowHandle window) => - DllImport.GetWindowPixelFormat(window); + public static IconvDataTHandle IconvOpen( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode + ) => DllImport.IconvOpen(tocode, fromcode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowPosition(WindowHandle window, int* x, int* y) => + sbyte* ISdl.IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => ( - (delegate* unmanaged)( - _slots[443] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[632] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[443] = nativeContext.LoadFunction("SDL_GetWindowPosition", "SDL3") + : _slots[632] = nativeContext.LoadFunction("SDL_iconv_string", "SDL3") ) - )(window, x, y); + )(tocode, fromcode, inbuf, inbytesleft); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowPosition(WindowHandle window, int* x, int* y) => - DllImport.GetWindowPosition(window, x, y); + public static sbyte* IconvString( + [NativeTypeName("const char *")] sbyte* tocode, + [NativeTypeName("const char *")] sbyte* fromcode, + [NativeTypeName("const char *")] sbyte* inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => DllImport.IconvString(tocode, fromcode, inbuf, inbytesleft); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowPosition(WindowHandle window, Ref x, Ref y) + Ptr ISdl.IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) { - fixed (int* __dsl_y = y) - fixed (int* __dsl_x = x) + fixed (sbyte* __dsl_inbuf = inbuf) + fixed (sbyte* __dsl_fromcode = fromcode) + fixed (sbyte* __dsl_tocode = tocode) { - return (MaybeBool)(byte)((ISdl)this).GetWindowPosition(window, __dsl_x, __dsl_y); + return (sbyte*) + ((ISdl)this).IconvString(__dsl_tocode, __dsl_fromcode, __dsl_inbuf, inbytesleft); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_iconv_string")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowPosition(WindowHandle window, Ref x, Ref y) => - DllImport.GetWindowPosition(window, x, y); + public static Ptr IconvString( + [NativeTypeName("const char *")] Ref tocode, + [NativeTypeName("const char *")] Ref fromcode, + [NativeTypeName("const char *")] Ref inbuf, + [NativeTypeName("size_t")] nuint inbytesleft + ) => DllImport.IconvString(tocode, fromcode, inbuf, inbytesleft); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.GetWindowProperties(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[444] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[444] = nativeContext.LoadFunction("SDL_GetWindowProperties", "SDL3") - ) - )(window); + MaybeBool ISdl.Init([NativeTypeName("SDL_InitFlags")] uint flags) => + (MaybeBool)(byte)((ISdl)this).InitRaw(flags); - [return: NativeTypeName("SDL_PropertiesID")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowProperties")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint GetWindowProperties(WindowHandle window) => - DllImport.GetWindowProperties(window); + public static MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => + DllImport.Init(flags); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowRelativeMouseMode(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).GetWindowRelativeMouseModeRaw(window); + MaybeBool ISdl.InitHapticRumble(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).InitHapticRumbleRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowRelativeMouseMode(WindowHandle window) => - DllImport.GetWindowRelativeMouseMode(window); + public static MaybeBool InitHapticRumble(HapticHandle haptic) => + DllImport.InitHapticRumble(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowRelativeMouseModeRaw(WindowHandle window) => + byte ISdl.InitHapticRumbleRaw(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[445] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[634] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[445] = nativeContext.LoadFunction( - "SDL_GetWindowRelativeMouseMode", - "SDL3" - ) + : _slots[634] = nativeContext.LoadFunction("SDL_InitHapticRumble", "SDL3") ) - )(window); + )(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowRelativeMouseModeRaw(WindowHandle window) => - DllImport.GetWindowRelativeMouseModeRaw(window); + public static byte InitHapticRumbleRaw(HapticHandle haptic) => + DllImport.InitHapticRumbleRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle* ISdl.GetWindows(int* count) => + byte ISdl.InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => ( - (delegate* unmanaged)( - _slots[446] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[633] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[446] = nativeContext.LoadFunction("SDL_GetWindows", "SDL3") + : _slots[633] = nativeContext.LoadFunction("SDL_Init", "SDL3") ) - )(count); + )(flags); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Init")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle* GetWindows(int* count) => DllImport.GetWindows(count); + public static byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + DllImport.InitRaw(flags); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindows(Ref count) - { - fixed (int* __dsl_count = count) - { - return (WindowHandle*)((ISdl)this).GetWindows(__dsl_count); - } - } + MaybeBool ISdl.InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + (MaybeBool)(byte)((ISdl)this).InitSubSystemRaw(flags); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindows")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindows(Ref count) => DllImport.GetWindows(count); + public static MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + DllImport.InitSubSystem(flags); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowSafeArea(WindowHandle window, Rect* rect) => + byte ISdl.InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => ( - (delegate* unmanaged)( - _slots[447] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[635] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[447] = nativeContext.LoadFunction("SDL_GetWindowSafeArea", "SDL3") + : _slots[635] = nativeContext.LoadFunction("SDL_InitSubSystem", "SDL3") ) - )(window, rect); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowSafeArea(WindowHandle window, Rect* rect) => - DllImport.GetWindowSafeArea(window, rect); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowSafeArea(WindowHandle window, Ref rect) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)((ISdl)this).GetWindowSafeArea(window, __dsl_rect); - } - } + )(flags); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSafeArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowSafeArea(WindowHandle window, Ref rect) => - DllImport.GetWindowSafeArea(window, rect); + public static byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + DllImport.InitSubSystemRaw(flags); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowSize(WindowHandle window, int* w, int* h) => + void ISdl.InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ) => ( - (delegate* unmanaged)( - _slots[448] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[636] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[448] = nativeContext.LoadFunction("SDL_GetWindowSize", "SDL3") + : _slots[636] = nativeContext.LoadFunction("SDL_InsertGPUDebugLabel", "SDL3") ) - )(window, w, h); + )(command_buffer, text); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowSize(WindowHandle window, int* w, int* h) => - DllImport.GetWindowSize(window, w, h); + public static void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* text + ) => DllImport.InsertGPUDebugLabel(command_buffer, text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowSize(WindowHandle window, Ref w, Ref h) + void ISdl.InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (sbyte* __dsl_text = text) { - return (MaybeBool)(byte)((ISdl)this).GetWindowSize(window, __dsl_w, __dsl_h); + ((ISdl)this).InsertGPUDebugLabel(command_buffer, __dsl_text); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_InsertGPUDebugLabel")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowSize(WindowHandle window, Ref w, Ref h) => - DllImport.GetWindowSize(window, w, h); + public static void InsertGPUDebugLabel( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref text + ) => DllImport.InsertGPUDebugLabel(command_buffer, text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => + IOStreamHandle ISdl.IOFromConstMem( + [NativeTypeName("const void *")] void* mem, + [NativeTypeName("size_t")] nuint size + ) => ( - (delegate* unmanaged)( - _slots[449] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[637] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[449] = nativeContext.LoadFunction("SDL_GetWindowSizeInPixels", "SDL3") + : _slots[637] = nativeContext.LoadFunction("SDL_IOFromConstMem", "SDL3") ) - )(window, w, h); + )(mem, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowSizeInPixels(WindowHandle window, int* w, int* h) => - DllImport.GetWindowSizeInPixels(window, w, h); + public static IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] void* mem, + [NativeTypeName("size_t")] nuint size + ) => DllImport.IOFromConstMem(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowSizeInPixels(WindowHandle window, Ref w, Ref h) + IOStreamHandle ISdl.IOFromConstMem( + [NativeTypeName("const void *")] Ref mem, + [NativeTypeName("size_t")] nuint size + ) { - fixed (int* __dsl_h = h) - fixed (int* __dsl_w = w) + fixed (void* __dsl_mem = mem) { - return (MaybeBool) - (byte)((ISdl)this).GetWindowSizeInPixels(window, __dsl_w, __dsl_h); + return (IOStreamHandle)((ISdl)this).IOFromConstMem(__dsl_mem, size); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSizeInPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowSizeInPixels( - WindowHandle window, - Ref w, - Ref h - ) => DllImport.GetWindowSizeInPixels(window, w, h); + public static IOStreamHandle IOFromConstMem( + [NativeTypeName("const void *")] Ref mem, + [NativeTypeName("size_t")] nuint size + ) => DllImport.IOFromConstMem(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindowSurface(WindowHandle window) => - (Surface*)((ISdl)this).GetWindowSurfaceRaw(window); + IOStreamHandle ISdl.IOFromDynamicMem() => + ( + (delegate* unmanaged)( + _slots[638] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[638] = nativeContext.LoadFunction("SDL_IOFromDynamicMem", "SDL3") + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindowSurface(WindowHandle window) => - DllImport.GetWindowSurface(window); + public static IOStreamHandle IOFromDynamicMem() => DllImport.IOFromDynamicMem(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.GetWindowSurfaceRaw(WindowHandle window) => + IOStreamHandle ISdl.IOFromFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("const char *")] sbyte* mode + ) => ( - (delegate* unmanaged)( - _slots[450] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[639] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[450] = nativeContext.LoadFunction("SDL_GetWindowSurface", "SDL3") + : _slots[639] = nativeContext.LoadFunction("SDL_IOFromFile", "SDL3") ) - )(window); + )(file, mode); - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* GetWindowSurfaceRaw(WindowHandle window) => - DllImport.GetWindowSurfaceRaw(window); + public static IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("const char *")] sbyte* mode + ) => DllImport.IOFromFile(file, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GetWindowSurfaceVSync(WindowHandle window, int* vsync) => + IOStreamHandle ISdl.IOFromFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("const char *")] Ref mode + ) + { + fixed (sbyte* __dsl_mode = mode) + fixed (sbyte* __dsl_file = file) + { + return (IOStreamHandle)((ISdl)this).IOFromFile(__dsl_file, __dsl_mode); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static IOStreamHandle IOFromFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("const char *")] Ref mode + ) => DllImport.IOFromFile(file, mode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + IOStreamHandle ISdl.IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => ( - (delegate* unmanaged)( - _slots[451] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[640] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[451] = nativeContext.LoadFunction("SDL_GetWindowSurfaceVSync", "SDL3") + : _slots[640] = nativeContext.LoadFunction("SDL_IOFromMem", "SDL3") ) - )(window, vsync); + )(mem, size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GetWindowSurfaceVSync(WindowHandle window, int* vsync) => - DllImport.GetWindowSurfaceVSync(window, vsync); + public static IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => + DllImport.IOFromMem(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GetWindowSurfaceVSync(WindowHandle window, Ref vsync) + IOStreamHandle ISdl.IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) { - fixed (int* __dsl_vsync = vsync) + fixed (void* __dsl_mem = mem) { - return (MaybeBool)(byte)((ISdl)this).GetWindowSurfaceVSync(window, __dsl_vsync); + return (IOStreamHandle)((ISdl)this).IOFromMem(__dsl_mem, size); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GetWindowSurfaceVSync(WindowHandle window, Ref vsync) => - DllImport.GetWindowSurfaceVSync(window, vsync); + public static IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) => + DllImport.IOFromMem(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.GetWindowTitle(WindowHandle window) => - (sbyte*)((ISdl)this).GetWindowTitleRaw(window); + nuint ISdl.IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => + ( + (delegate* unmanaged)( + _slots[641] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[641] = nativeContext.LoadFunction("SDL_IOvprintf", "SDL3") + ) + )(context, fmt, ap); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.IOvprintf(context, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + { + return (nuint)((ISdl)this).IOvprintf(context, __dsl_fmt, __dsl_ap); + } + } - [return: NativeTypeName("const char *")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr GetWindowTitle(WindowHandle window) => - DllImport.GetWindowTitle(window); + public static nuint IOvprintf( + IOStreamHandle context, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.IOvprintf(context, fmt, ap); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte* ISdl.GetWindowTitleRaw(WindowHandle window) => + int ISdl.Isalnum(int x) => ( - (delegate* unmanaged)( - _slots[452] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[642] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[452] = nativeContext.LoadFunction("SDL_GetWindowTitle", "SDL3") + : _slots[642] = nativeContext.LoadFunction("SDL_isalnum", "SDL3") ) - )(window); + )(x); - [return: NativeTypeName("const char *")] - [NativeFunction("SDL3", EntryPoint = "SDL_GetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_isalnum")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte* GetWindowTitleRaw(WindowHandle window) => - DllImport.GetWindowTitleRaw(window); + public static int Isalnum(int x) => DllImport.Isalnum(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GLContextStateHandle ISdl.GLCreateContext(WindowHandle window) => + int ISdl.Isalpha(int x) => ( - (delegate* unmanaged)( - _slots[453] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[643] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[453] = nativeContext.LoadFunction("SDL_GL_CreateContext", "SDL3") + : _slots[643] = nativeContext.LoadFunction("SDL_isalpha", "SDL3") ) - )(window); + )(x); - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_CreateContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_isalpha")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GLContextStateHandle GLCreateContext(WindowHandle window) => - DllImport.GLCreateContext(window); + public static int Isalpha(int x) => DllImport.Isalpha(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLDestroyContext( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => (MaybeBool)(byte)((ISdl)this).GLDestroyContextRaw(context); + int ISdl.Isblank(int x) => + ( + (delegate* unmanaged)( + _slots[644] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[644] = nativeContext.LoadFunction("SDL_isblank", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_isblank")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLDestroyContext( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => DllImport.GLDestroyContext(context); + public static int Isblank(int x) => DllImport.Isblank(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLDestroyContextRaw([NativeTypeName("SDL_GLContext")] GLContextStateHandle context) => + int ISdl.Iscntrl(int x) => ( - (delegate* unmanaged)( - _slots[454] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[645] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[454] = nativeContext.LoadFunction("SDL_GL_DestroyContext", "SDL3") + : _slots[645] = nativeContext.LoadFunction("SDL_iscntrl", "SDL3") ) - )(context); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_DestroyContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_iscntrl")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLDestroyContextRaw( - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => DllImport.GLDestroyContextRaw(context); + public static int Iscntrl(int x) => DllImport.Iscntrl(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => + int ISdl.Isdigit(int x) => ( - (delegate* unmanaged)( - _slots[455] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[646] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[455] = nativeContext.LoadFunction("SDL_GL_ExtensionSupported", "SDL3") + : _slots[646] = nativeContext.LoadFunction("SDL_isdigit", "SDL3") ) - )(extension); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_isdigit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLExtensionSupported([NativeTypeName("const char *")] sbyte* extension) => - DllImport.GLExtensionSupported(extension); + public static int Isdigit(int x) => DllImport.Isdigit(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLExtensionSupported([NativeTypeName("const char *")] Ref extension) - { - fixed (sbyte* __dsl_extension = extension) - { - return (MaybeBool)(byte)((ISdl)this).GLExtensionSupported(__dsl_extension); - } - } + MaybeBool ISdl.IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (MaybeBool)(byte)((ISdl)this).IsGamepadRaw(instance_id); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ExtensionSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLExtensionSupported( - [NativeTypeName("const char *")] Ref extension - ) => DllImport.GLExtensionSupported(extension); + public static MaybeBool IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.IsGamepad(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLGetAttribute(GLAttr attr, int* value) => + byte ISdl.IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[456] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[647] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[456] = nativeContext.LoadFunction("SDL_GL_GetAttribute", "SDL3") + : _slots[647] = nativeContext.LoadFunction("SDL_IsGamepad", "SDL3") ) - )(attr, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLGetAttribute(GLAttr attr, int* value) => - DllImport.GLGetAttribute(attr, value); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLGetAttribute(GLAttr attr, Ref value) - { - fixed (int* __dsl_value = value) - { - return (MaybeBool)(byte)((ISdl)this).GLGetAttribute(attr, __dsl_value); - } - } + )(instance_id); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLGetAttribute(GLAttr attr, Ref value) => - DllImport.GLGetAttribute(attr, value); + public static byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.IsGamepadRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GLContextStateHandle ISdl.GLGetCurrentContext() => + int ISdl.Isgraph(int x) => ( - (delegate* unmanaged)( - _slots[457] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[648] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[457] = nativeContext.LoadFunction("SDL_GL_GetCurrentContext", "SDL3") + : _slots[648] = nativeContext.LoadFunction("SDL_isgraph", "SDL3") ) - )(); + )(x); - [return: NativeTypeName("SDL_GLContext")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentContext")] + [NativeFunction("SDL3", EntryPoint = "SDL_isgraph")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GLContextStateHandle GLGetCurrentContext() => DllImport.GLGetCurrentContext(); + public static int Isgraph(int x) => DllImport.Isgraph(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - WindowHandle ISdl.GLGetCurrentWindow() => + int ISdl.Isinf(double x) => ( - (delegate* unmanaged)( - _slots[458] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[649] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[458] = nativeContext.LoadFunction("SDL_GL_GetCurrentWindow", "SDL3") + : _slots[649] = nativeContext.LoadFunction("SDL_isinf", "SDL3") ) - )(); + )(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetCurrentWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_isinf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static WindowHandle GLGetCurrentWindow() => DllImport.GLGetCurrentWindow(); + public static int Isinf(double x) => DllImport.Isinf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => + int ISdl.Isinff(float x) => ( - (delegate* unmanaged)( - _slots[459] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[650] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[459] = nativeContext.LoadFunction("SDL_GL_GetProcAddress", "SDL3") + : _slots[650] = nativeContext.LoadFunction("SDL_isinff", "SDL3") ) - )(proc); + )(x); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_isinff")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer GLGetProcAddress([NativeTypeName("const char *")] sbyte* proc) => - DllImport.GLGetProcAddress(proc); + public static int Isinff(float x) => DllImport.Isinff(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.GLGetProcAddress([NativeTypeName("const char *")] Ref proc) - { - fixed (sbyte* __dsl_proc = proc) - { - return (FunctionPointer)((ISdl)this).GLGetProcAddress(__dsl_proc); - } - } + MaybeBool ISdl.IsJoystickHaptic(JoystickHandle joystick) => + (MaybeBool)(byte)((ISdl)this).IsJoystickHapticRaw(joystick); - [return: NativeTypeName("SDL_FunctionPointer")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetProcAddress")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer GLGetProcAddress( - [NativeTypeName("const char *")] Ref proc - ) => DllImport.GLGetProcAddress(proc); + public static MaybeBool IsJoystickHaptic(JoystickHandle joystick) => + DllImport.IsJoystickHaptic(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLGetSwapInterval(int* interval) => + byte ISdl.IsJoystickHapticRaw(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[460] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[651] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[460] = nativeContext.LoadFunction("SDL_GL_GetSwapInterval", "SDL3") + : _slots[651] = nativeContext.LoadFunction("SDL_IsJoystickHaptic", "SDL3") ) - )(interval); + )(joystick); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLGetSwapInterval(int* interval) => DllImport.GLGetSwapInterval(interval); + public static byte IsJoystickHapticRaw(JoystickHandle joystick) => + DllImport.IsJoystickHapticRaw(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLGetSwapInterval(Ref interval) - { - fixed (int* __dsl_interval = interval) - { - return (MaybeBool)(byte)((ISdl)this).GLGetSwapInterval(__dsl_interval); - } - } + MaybeBool ISdl.IsJoystickVirtual([NativeTypeName("SDL_JoystickID")] uint instance_id) => + (MaybeBool)(byte)((ISdl)this).IsJoystickVirtualRaw(instance_id); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_GetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLGetSwapInterval(Ref interval) => - DllImport.GLGetSwapInterval(interval); + public static MaybeBool IsJoystickVirtual( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.IsJoystickVirtual(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + byte ISdl.IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[461] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[652] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[461] = nativeContext.LoadFunction("SDL_GL_LoadLibrary", "SDL3") + : _slots[652] = nativeContext.LoadFunction("SDL_IsJoystickVirtual", "SDL3") ) - )(path); + )(instance_id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLLoadLibrary([NativeTypeName("const char *")] sbyte* path) => - DllImport.GLLoadLibrary(path); + public static byte IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.IsJoystickVirtualRaw(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLLoadLibrary([NativeTypeName("const char *")] Ref path) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)((ISdl)this).GLLoadLibrary(__dsl_path); - } - } + int ISdl.Islower(int x) => + ( + (delegate* unmanaged)( + _slots[653] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[653] = nativeContext.LoadFunction("SDL_islower", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_LoadLibrary")] + [NativeFunction("SDL3", EntryPoint = "SDL_islower")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLLoadLibrary([NativeTypeName("const char *")] Ref path) => - DllImport.GLLoadLibrary(path); + public static int Islower(int x) => DllImport.Islower(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLMakeCurrent( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => (MaybeBool)(byte)((ISdl)this).GLMakeCurrentRaw(window, context); + MaybeBool ISdl.IsMouseHaptic() => (MaybeBool)(byte)((ISdl)this).IsMouseHapticRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLMakeCurrent( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => DllImport.GLMakeCurrent(window, context); + public static MaybeBool IsMouseHaptic() => DllImport.IsMouseHaptic(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLMakeCurrentRaw( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => + byte ISdl.IsMouseHapticRaw() => ( - (delegate* unmanaged)( - _slots[462] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[654] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[462] = nativeContext.LoadFunction("SDL_GL_MakeCurrent", "SDL3") + : _slots[654] = nativeContext.LoadFunction("SDL_IsMouseHaptic", "SDL3") ) - )(window, context); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_MakeCurrent")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLMakeCurrentRaw( - WindowHandle window, - [NativeTypeName("SDL_GLContext")] GLContextStateHandle context - ) => DllImport.GLMakeCurrentRaw(window, context); + public static byte IsMouseHapticRaw() => DllImport.IsMouseHapticRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GLResetAttributes() => + int ISdl.Isnan(double x) => ( - (delegate* unmanaged)( - _slots[463] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[655] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[463] = nativeContext.LoadFunction("SDL_GL_ResetAttributes", "SDL3") + : _slots[655] = nativeContext.LoadFunction("SDL_isnan", "SDL3") ) - )(); + )(x); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_ResetAttributes")] + [NativeFunction("SDL3", EntryPoint = "SDL_isnan")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GLResetAttributes() => DllImport.GLResetAttributes(); + public static int Isnan(double x) => DllImport.Isnan(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLSetAttribute(GLAttr attr, int value) => - (MaybeBool)(byte)((ISdl)this).GLSetAttributeRaw(attr, value); + int ISdl.Isnanf(float x) => + ( + (delegate* unmanaged)( + _slots[656] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[656] = nativeContext.LoadFunction("SDL_isnanf", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_isnanf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLSetAttribute(GLAttr attr, int value) => - DllImport.GLSetAttribute(attr, value); + public static int Isnanf(float x) => DllImport.Isnanf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLSetAttributeRaw(GLAttr attr, int value) => + int ISdl.Isprint(int x) => ( - (delegate* unmanaged)( - _slots[464] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[657] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[464] = nativeContext.LoadFunction("SDL_GL_SetAttribute", "SDL3") + : _slots[657] = nativeContext.LoadFunction("SDL_isprint", "SDL3") ) - )(attr, value); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetAttribute")] + [NativeFunction("SDL3", EntryPoint = "SDL_isprint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLSetAttributeRaw(GLAttr attr, int value) => - DllImport.GLSetAttributeRaw(attr, value); + public static int Isprint(int x) => DllImport.Isprint(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLSetSwapInterval(int interval) => - (MaybeBool)(byte)((ISdl)this).GLSetSwapIntervalRaw(interval); + int ISdl.Ispunct(int x) => + ( + (delegate* unmanaged)( + _slots[658] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[658] = nativeContext.LoadFunction("SDL_ispunct", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_ispunct")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLSetSwapInterval(int interval) => - DllImport.GLSetSwapInterval(interval); + public static int Ispunct(int x) => DllImport.Ispunct(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLSetSwapIntervalRaw(int interval) => + int ISdl.Isspace(int x) => ( - (delegate* unmanaged)( - _slots[465] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[659] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[465] = nativeContext.LoadFunction("SDL_GL_SetSwapInterval", "SDL3") + : _slots[659] = nativeContext.LoadFunction("SDL_isspace", "SDL3") ) - )(interval); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SetSwapInterval")] + [NativeFunction("SDL3", EntryPoint = "SDL_isspace")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLSetSwapIntervalRaw(int interval) => - DllImport.GLSetSwapIntervalRaw(interval); + public static int Isspace(int x) => DllImport.Isspace(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.GLSwapWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).GLSwapWindowRaw(window); + MaybeBool ISdl.IsTablet() => (MaybeBool)(byte)((ISdl)this).IsTabletRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool GLSwapWindow(WindowHandle window) => - DllImport.GLSwapWindow(window); + public static MaybeBool IsTablet() => DllImport.IsTablet(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.GLSwapWindowRaw(WindowHandle window) => + byte ISdl.IsTabletRaw() => ( - (delegate* unmanaged)( - _slots[466] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[660] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[466] = nativeContext.LoadFunction("SDL_GL_SwapWindow", "SDL3") + : _slots[660] = nativeContext.LoadFunction("SDL_IsTablet", "SDL3") ) - )(window); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_GL_SwapWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte GLSwapWindowRaw(WindowHandle window) => DllImport.GLSwapWindowRaw(window); + public static byte IsTabletRaw() => DllImport.IsTabletRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GLUnloadLibrary() => + MaybeBool ISdl.IsTV() => (MaybeBool)(byte)((ISdl)this).IsTVRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool IsTV() => DllImport.IsTV(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.IsTVRaw() => ( - (delegate* unmanaged)( - _slots[467] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[661] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[467] = nativeContext.LoadFunction("SDL_GL_UnloadLibrary", "SDL3") + : _slots[661] = nativeContext.LoadFunction("SDL_IsTV", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_GL_UnloadLibrary")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GLUnloadLibrary() => DllImport.GLUnloadLibrary(); + public static byte IsTVRaw() => DllImport.IsTVRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte** ISdl.GlobDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => + int ISdl.Isupper(int x) => ( - (delegate* unmanaged)( - _slots[468] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[662] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[468] = nativeContext.LoadFunction("SDL_GlobDirectory", "SDL3") + : _slots[662] = nativeContext.LoadFunction("SDL_isupper", "SDL3") ) - )(path, pattern, flags, count); + )(x); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_isupper")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte** GlobDirectory( - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => DllImport.GlobDirectory(path, pattern, flags, count); + public static int Isupper(int x) => DllImport.Isupper(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GlobDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) - { - fixed (int* __dsl_count = count) - fixed (sbyte* __dsl_pattern = pattern) - fixed (sbyte* __dsl_path = path) - { - return (sbyte**) - ((ISdl)this).GlobDirectory(__dsl_path, __dsl_pattern, flags, __dsl_count); - } - } + int ISdl.Isxdigit(int x) => + ( + (delegate* unmanaged)( + _slots[663] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[663] = nativeContext.LoadFunction("SDL_isxdigit", "SDL3") + ) + )(x); - [return: NativeTypeName("char **")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobDirectory")] + [NativeFunction("SDL3", EntryPoint = "SDL_isxdigit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GlobDirectory( - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) => DllImport.GlobDirectory(path, pattern, flags, count); + public static int Isxdigit(int x) => DllImport.Isxdigit(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - sbyte** ISdl.GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => + sbyte* ISdl.Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix) => ( - (delegate* unmanaged)( - _slots[469] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[664] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[469] = nativeContext.LoadFunction("SDL_GlobStorageDirectory", "SDL3") + : _slots[664] = nativeContext.LoadFunction("SDL_itoa", "SDL3") ) - )(storage, path, pattern, flags, count); + )(value, str, radix); - [return: NativeTypeName("char **")] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static sbyte** GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - [NativeTypeName("const char *")] sbyte* pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - int* count - ) => DllImport.GlobStorageDirectory(storage, path, pattern, flags, count); + public static sbyte* Itoa(int value, [NativeTypeName("char *")] sbyte* str, int radix) => + DllImport.Itoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr2D ISdl.GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) + Ptr ISdl.Itoa(int value, [NativeTypeName("char *")] Ref str, int radix) { - fixed (int* __dsl_count = count) - fixed (sbyte* __dsl_pattern = pattern) - fixed (sbyte* __dsl_path = path) + fixed (sbyte* __dsl_str = str) { - return (sbyte**) - ((ISdl)this).GlobStorageDirectory( - storage, - __dsl_path, - __dsl_pattern, - flags, - __dsl_count - ); + return (sbyte*)((ISdl)this).Itoa(value, __dsl_str, radix); } } - [return: NativeTypeName("char **")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GlobStorageDirectory")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr2D GlobStorageDirectory( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - [NativeTypeName("const char *")] Ref pattern, - [NativeTypeName("SDL_GlobFlags")] uint flags, - Ref count - ) => DllImport.GlobStorageDirectory(storage, path, pattern, flags, count); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GuidToString(Guid guid, [NativeTypeName("char *")] sbyte* pszGUID, int cbGUID) => - ( - (delegate* unmanaged)( - _slots[470] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[470] = nativeContext.LoadFunction("SDL_GUIDToString", "SDL3") - ) - )(guid, pszGUID, cbGUID); - - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [NativeFunction("SDL3", EntryPoint = "SDL_itoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GuidToString( - Guid guid, - [NativeTypeName("char *")] sbyte* pszGUID, - int cbGUID - ) => DllImport.GuidToString(guid, pszGUID, cbGUID); + public static Ptr Itoa( + int value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Itoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.GuidToString(Guid guid, [NativeTypeName("char *")] Ref pszGUID, int cbGUID) - { - fixed (sbyte* __dsl_pszGUID = pszGUID) - { - ((ISdl)this).GuidToString(guid, __dsl_pszGUID, cbGUID); - } - } + MaybeBool ISdl.JoystickConnected(JoystickHandle joystick) => + (MaybeBool)(byte)((ISdl)this).JoystickConnectedRaw(joystick); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_GUIDToString")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void GuidToString( - Guid guid, - [NativeTypeName("char *")] Ref pszGUID, - int cbGUID - ) => DllImport.GuidToString(guid, pszGUID, cbGUID); + public static MaybeBool JoystickConnected(JoystickHandle joystick) => + DllImport.JoystickConnected(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => + byte ISdl.JoystickConnectedRaw(JoystickHandle joystick) => ( - (delegate* unmanaged)( - _slots[471] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[665] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[471] = nativeContext.LoadFunction("SDL_HapticEffectSupported", "SDL3") + : _slots[665] = nativeContext.LoadFunction("SDL_JoystickConnected", "SDL3") ) - )(haptic, effect); + )(joystick); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] HapticEffect* effect - ) => DllImport.HapticEffectSupported(haptic, effect); + public static byte JoystickConnectedRaw(JoystickHandle joystick) => + DllImport.JoystickConnectedRaw(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) - { - fixed (HapticEffect* __dsl_effect = effect) - { - return (MaybeBool)(byte)((ISdl)this).HapticEffectSupported(haptic, __dsl_effect); - } - } + MaybeBool ISdl.JoystickEventsEnabled() => + (MaybeBool)(byte)((ISdl)this).JoystickEventsEnabledRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticEffectSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HapticEffectSupported( - HapticHandle haptic, - [NativeTypeName("const SDL_HapticEffect *")] Ref effect - ) => DllImport.HapticEffectSupported(haptic, effect); + public static MaybeBool JoystickEventsEnabled() => DllImport.JoystickEventsEnabled(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HapticRumbleSupported(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).HapticRumbleSupportedRaw(haptic); + byte ISdl.JoystickEventsEnabledRaw() => + ( + (delegate* unmanaged)( + _slots[666] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[666] = nativeContext.LoadFunction("SDL_JoystickEventsEnabled", "SDL3") + ) + )(); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HapticRumbleSupported(HapticHandle haptic) => - DllImport.HapticRumbleSupported(haptic); + public static byte JoystickEventsEnabledRaw() => DllImport.JoystickEventsEnabledRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HapticRumbleSupportedRaw(HapticHandle haptic) => + byte ISdl.KillProcess(ProcessHandle process, [NativeTypeName("bool")] byte force) => ( - (delegate* unmanaged)( - _slots[472] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[667] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[472] = nativeContext.LoadFunction("SDL_HapticRumbleSupported", "SDL3") + : _slots[667] = nativeContext.LoadFunction("SDL_KillProcess", "SDL3") ) - )(haptic); + )(process, force); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HapticRumbleSupported")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HapticRumbleSupportedRaw(HapticHandle haptic) => - DllImport.HapticRumbleSupportedRaw(haptic); + public static byte KillProcess(ProcessHandle process, [NativeTypeName("bool")] byte force) => + DllImport.KillProcess(process, force); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasAltiVec() => (MaybeBool)(byte)((ISdl)this).HasAltiVecRaw(); + MaybeBool ISdl.KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ) => (MaybeBool)(byte)((ISdl)this).KillProcess(process, (byte)force); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] + [NativeFunction("SDL3", EntryPoint = "SDL_KillProcess")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasAltiVec() => DllImport.HasAltiVec(); + public static MaybeBool KillProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool force + ) => DllImport.KillProcess(process, force); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasAltiVecRaw() => + sbyte* ISdl.Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => ( - (delegate* unmanaged)( - _slots[473] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[668] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[473] = nativeContext.LoadFunction("SDL_HasAltiVec", "SDL3") + : _slots[668] = nativeContext.LoadFunction("SDL_lltoa", "SDL3") ) - )(); + )(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAltiVec")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasAltiVecRaw() => DllImport.HasAltiVecRaw(); + public static sbyte* Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => DllImport.Lltoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasArmsimd() => (MaybeBool)(byte)((ISdl)this).HasArmsimdRaw(); + Ptr ISdl.Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Lltoa(value, __dsl_str, radix); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [NativeFunction("SDL3", EntryPoint = "SDL_lltoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasArmsimd() => DllImport.HasArmsimd(); + public static Ptr Lltoa( + [NativeTypeName("long long")] long value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Lltoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasArmsimdRaw() => + Surface* ISdl.LoadBMP([NativeTypeName("const char *")] sbyte* file) => ( - (delegate* unmanaged)( - _slots[474] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[669] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[474] = nativeContext.LoadFunction("SDL_HasARMSIMD", "SDL3") + : _slots[669] = nativeContext.LoadFunction("SDL_LoadBMP", "SDL3") ) - )(); + )(file); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasARMSIMD")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasArmsimdRaw() => DllImport.HasArmsimdRaw(); + public static Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => + DllImport.LoadBMP(file); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasAVX() => (MaybeBool)(byte)((ISdl)this).HasAVXRaw(); + Ptr ISdl.LoadBMP([NativeTypeName("const char *")] Ref file) + { + fixed (sbyte* __dsl_file = file) + { + return (Surface*)((ISdl)this).LoadBMP(__dsl_file); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasAVX() => DllImport.HasAVX(); + public static Ptr LoadBMP([NativeTypeName("const char *")] Ref file) => + DllImport.LoadBMP(file); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasAVX2() => (MaybeBool)(byte)((ISdl)this).HasAVX2Raw(); + Surface* ISdl.LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => + ( + (delegate* unmanaged)( + _slots[670] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[670] = nativeContext.LoadFunction("SDL_LoadBMP_IO", "SDL3") + ) + )(src, closeio); + + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Surface* LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => + DllImport.LoadBMPIO(src, closeio); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.LoadBMPIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => (Surface*)((ISdl)this).LoadBMPIO(src, (byte)closeio); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasAVX2() => DllImport.HasAVX2(); + public static Ptr LoadBMPIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio + ) => DllImport.LoadBMPIO(src, closeio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasAVX2Raw() => + void* ISdl.LoadFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("size_t *")] nuint* datasize + ) => ( - (delegate* unmanaged)( - _slots[476] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[671] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[476] = nativeContext.LoadFunction("SDL_HasAVX2", "SDL3") + : _slots[671] = nativeContext.LoadFunction("SDL_LoadFile", "SDL3") ) - )(); + )(file, datasize); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX2")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasAVX2Raw() => DllImport.HasAVX2Raw(); + public static void* LoadFile( + [NativeTypeName("const char *")] sbyte* file, + [NativeTypeName("size_t *")] nuint* datasize + ) => DllImport.LoadFile(file, datasize); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasAVX512F() => (MaybeBool)(byte)((ISdl)this).HasAVX512FRaw(); + Ptr ISdl.LoadFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("size_t *")] Ref datasize + ) + { + fixed (nuint* __dsl_datasize = datasize) + fixed (sbyte* __dsl_file = file) + { + return (void*)((ISdl)this).LoadFile(__dsl_file, __dsl_datasize); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasAVX512F() => DllImport.HasAVX512F(); + public static Ptr LoadFile( + [NativeTypeName("const char *")] Ref file, + [NativeTypeName("size_t *")] Ref datasize + ) => DllImport.LoadFile(file, datasize); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasAVX512FRaw() => + void* ISdl.LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] nuint* datasize, + [NativeTypeName("bool")] byte closeio + ) => ( - (delegate* unmanaged)( - _slots[477] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[672] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[477] = nativeContext.LoadFunction("SDL_HasAVX512F", "SDL3") + : _slots[672] = nativeContext.LoadFunction("SDL_LoadFile_IO", "SDL3") ) - )(); + )(src, datasize, closeio); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX512F")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasAVX512FRaw() => DllImport.HasAVX512FRaw(); + public static void* LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] nuint* datasize, + [NativeTypeName("bool")] byte closeio + ) => DllImport.LoadFileIO(src, datasize, closeio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasAVXRaw() => - ( - (delegate* unmanaged)( - _slots[475] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[475] = nativeContext.LoadFunction("SDL_HasAVX", "SDL3") - ) - )(); + Ptr ISdl.LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] Ref datasize, + [NativeTypeName("bool")] MaybeBool closeio + ) + { + fixed (nuint* __dsl_datasize = datasize) + { + return (void*)((ISdl)this).LoadFileIO(src, __dsl_datasize, (byte)closeio); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasAVX")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasAVXRaw() => DllImport.HasAVXRaw(); + public static Ptr LoadFileIO( + IOStreamHandle src, + [NativeTypeName("size_t *")] Ref datasize, + [NativeTypeName("bool")] MaybeBool closeio + ) => DllImport.LoadFileIO(src, datasize, closeio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => + FunctionPointer ISdl.LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] sbyte* name + ) => ( - (delegate* unmanaged)( - _slots[478] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[673] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[478] = nativeContext.LoadFunction("SDL_HasClipboardData", "SDL3") + : _slots[673] = nativeContext.LoadFunction("SDL_LoadFunction", "SDL3") ) - )(mime_type); + )(handle, name); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasClipboardData([NativeTypeName("const char *")] sbyte* mime_type) => - DllImport.HasClipboardData(mime_type); + public static FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.LoadFunction(handle, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasClipboardData([NativeTypeName("const char *")] Ref mime_type) + FunctionPointer ISdl.LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] Ref name + ) { - fixed (sbyte* __dsl_mime_type = mime_type) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).HasClipboardData(__dsl_mime_type); + return (FunctionPointer)((ISdl)this).LoadFunction(handle, __dsl_name); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasClipboardData( - [NativeTypeName("const char *")] Ref mime_type - ) => DllImport.HasClipboardData(mime_type); + public static FunctionPointer LoadFunction( + SharedObjectHandle handle, + [NativeTypeName("const char *")] Ref name + ) => DllImport.LoadFunction(handle, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasClipboardText() => - (MaybeBool)(byte)((ISdl)this).HasClipboardTextRaw(); + SharedObjectHandle ISdl.LoadObject([NativeTypeName("const char *")] sbyte* sofile) => + ( + (delegate* unmanaged)( + _slots[674] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[674] = nativeContext.LoadFunction("SDL_LoadObject", "SDL3") + ) + )(sofile); + + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static SharedObjectHandle LoadObject([NativeTypeName("const char *")] sbyte* sofile) => + DllImport.LoadObject(sofile); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + SharedObjectHandle ISdl.LoadObject([NativeTypeName("const char *")] Ref sofile) + { + fixed (sbyte* __dsl_sofile = sofile) + { + return (SharedObjectHandle)((ISdl)this).LoadObject(__dsl_sofile); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasClipboardText() => DllImport.HasClipboardText(); + public static SharedObjectHandle LoadObject( + [NativeTypeName("const char *")] Ref sofile + ) => DllImport.LoadObject(sofile); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasClipboardTextRaw() => + byte ISdl.LoadWAV( + [NativeTypeName("const char *")] sbyte* path, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => ( - (delegate* unmanaged)( - _slots[479] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[675] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[479] = nativeContext.LoadFunction("SDL_HasClipboardText", "SDL3") + : _slots[675] = nativeContext.LoadFunction("SDL_LoadWAV", "SDL3") ) - )(); + )(path, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasClipboardTextRaw() => DllImport.HasClipboardTextRaw(); + public static byte LoadWAV( + [NativeTypeName("const char *")] sbyte* path, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => DllImport.LoadWAV(path, spec, audio_buf, audio_len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasEvent([NativeTypeName("Uint32")] uint type) => - (MaybeBool)(byte)((ISdl)this).HasEventRaw(type); + MaybeBool ISdl.LoadWAV( + [NativeTypeName("const char *")] Ref path, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) + { + fixed (uint* __dsl_audio_len = audio_len) + fixed (byte** __dsl_audio_buf = audio_buf) + fixed (AudioSpec* __dsl_spec = spec) + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool) + (byte) + ((ISdl)this).LoadWAV(__dsl_path, __dsl_spec, __dsl_audio_buf, __dsl_audio_len); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasEvent([NativeTypeName("Uint32")] uint type) => - DllImport.HasEvent(type); + public static MaybeBool LoadWAV( + [NativeTypeName("const char *")] Ref path, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) => DllImport.LoadWAV(path, spec, audio_buf, audio_len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasEventRaw([NativeTypeName("Uint32")] uint type) => + byte ISdl.LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => ( - (delegate* unmanaged)( - _slots[480] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[676] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[480] = nativeContext.LoadFunction("SDL_HasEvent", "SDL3") + : _slots[676] = nativeContext.LoadFunction("SDL_LoadWAV_IO", "SDL3") ) - )(type); + )(src, closeio, spec, audio_buf, audio_len); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasEventRaw([NativeTypeName("Uint32")] uint type) => - DllImport.HasEventRaw(type); + public static byte LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] byte closeio, + AudioSpec* spec, + [NativeTypeName("Uint8 **")] byte** audio_buf, + [NativeTypeName("Uint32 *")] uint* audio_len + ) => DllImport.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => (MaybeBool)(byte)((ISdl)this).HasEventsRaw(minType, maxType); + MaybeBool ISdl.LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) + { + fixed (uint* __dsl_audio_len = audio_len) + fixed (byte** __dsl_audio_buf = audio_buf) + fixed (AudioSpec* __dsl_spec = spec) + { + return (MaybeBool) + (byte) + ((ISdl)this).LoadWAVIO( + src, + (byte)closeio, + __dsl_spec, + __dsl_audio_buf, + __dsl_audio_len + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasEvents( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => DllImport.HasEvents(minType, maxType); + public static MaybeBool LoadWAVIO( + IOStreamHandle src, + [NativeTypeName("bool")] MaybeBool closeio, + Ref spec, + [NativeTypeName("Uint8 **")] Ref2D audio_buf, + [NativeTypeName("Uint32 *")] Ref audio_len + ) => DllImport.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasEventsRaw( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => + MaybeBool ISdl.LockAudioStream(AudioStreamHandle stream) => + (MaybeBool)(byte)((ISdl)this).LockAudioStreamRaw(stream); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool LockAudioStream(AudioStreamHandle stream) => + DllImport.LockAudioStream(stream); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.LockAudioStreamRaw(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[481] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[677] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[481] = nativeContext.LoadFunction("SDL_HasEvents", "SDL3") + : _slots[677] = nativeContext.LoadFunction("SDL_LockAudioStream", "SDL3") ) - )(minType, maxType); + )(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasEventsRaw( - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => DllImport.HasEventsRaw(minType, maxType); + public static byte LockAudioStreamRaw(AudioStreamHandle stream) => + DllImport.LockAudioStreamRaw(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasGamepad() => (MaybeBool)(byte)((ISdl)this).HasGamepadRaw(); + void ISdl.LockJoysticks() => + ( + (delegate* unmanaged)( + _slots[678] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[678] = nativeContext.LoadFunction("SDL_LockJoysticks", "SDL3") + ) + )(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasGamepad() => DllImport.HasGamepad(); + public static void LockJoysticks() => DllImport.LockJoysticks(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasGamepadRaw() => + void ISdl.LockMutex(MutexHandle mutex) => ( - (delegate* unmanaged)( - _slots[482] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[679] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[482] = nativeContext.LoadFunction("SDL_HasGamepad", "SDL3") + : _slots[679] = nativeContext.LoadFunction("SDL_LockMutex", "SDL3") ) - )(); + )(mutex); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasGamepadRaw() => DllImport.HasGamepadRaw(); + public static void LockMutex(MutexHandle mutex) => DllImport.LockMutex(mutex); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasJoystick() => (MaybeBool)(byte)((ISdl)this).HasJoystickRaw(); + MaybeBool ISdl.LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + (MaybeBool)(byte)((ISdl)this).LockPropertiesRaw(props); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasJoystick() => DllImport.HasJoystick(); + public static MaybeBool LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => + DllImport.LockProperties(props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasJoystickRaw() => + byte ISdl.LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => ( - (delegate* unmanaged)( - _slots[483] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[680] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[483] = nativeContext.LoadFunction("SDL_HasJoystick", "SDL3") + : _slots[680] = nativeContext.LoadFunction("SDL_LockProperties", "SDL3") ) - )(); + )(props); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasJoystickRaw() => DllImport.HasJoystickRaw(); + public static byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + DllImport.LockPropertiesRaw(props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasKeyboard() => (MaybeBool)(byte)((ISdl)this).HasKeyboardRaw(); + void ISdl.LockRWLockForReading(RWLockHandle rwlock) => + ( + (delegate* unmanaged)( + _slots[681] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[681] = nativeContext.LoadFunction("SDL_LockRWLockForReading", "SDL3") + ) + )(rwlock); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasKeyboard() => DllImport.HasKeyboard(); + public static void LockRWLockForReading(RWLockHandle rwlock) => + DllImport.LockRWLockForReading(rwlock); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasKeyboardRaw() => + void ISdl.LockRWLockForWriting(RWLockHandle rwlock) => ( - (delegate* unmanaged)( - _slots[484] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[682] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[484] = nativeContext.LoadFunction("SDL_HasKeyboard", "SDL3") + : _slots[682] = nativeContext.LoadFunction("SDL_LockRWLockForWriting", "SDL3") ) - )(); + )(rwlock); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasKeyboard")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasKeyboardRaw() => DllImport.HasKeyboardRaw(); + public static void LockRWLockForWriting(RWLockHandle rwlock) => + DllImport.LockRWLockForWriting(rwlock); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasLasx() => (MaybeBool)(byte)((ISdl)this).HasLasxRaw(); + void ISdl.LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + ( + (delegate* unmanaged)( + _slots[683] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[683] = nativeContext.LoadFunction("SDL_LockSpinlock", "SDL3") + ) + )(@lock); + + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + DllImport.LockSpinlock(@lock); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) + { + fixed (int* __dsl_lock = @lock) + { + ((ISdl)this).LockSpinlock(__dsl_lock); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasLasx() => DllImport.HasLasx(); + public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => + DllImport.LockSpinlock(@lock); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasLasxRaw() => + byte ISdl.LockSurface(Surface* surface) => ( - (delegate* unmanaged)( - _slots[485] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[684] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[485] = nativeContext.LoadFunction("SDL_HasLASX", "SDL3") + : _slots[684] = nativeContext.LoadFunction("SDL_LockSurface", "SDL3") ) - )(); + )(surface); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLASX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasLasxRaw() => DllImport.HasLasxRaw(); + public static byte LockSurface(Surface* surface) => DllImport.LockSurface(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasLSX() => (MaybeBool)(byte)((ISdl)this).HasLSXRaw(); + MaybeBool ISdl.LockSurface(Ref surface) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)((ISdl)this).LockSurface(__dsl_surface); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasLSX() => DllImport.HasLSX(); + public static MaybeBool LockSurface(Ref surface) => + DllImport.LockSurface(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasLSXRaw() => + byte ISdl.LockTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + void** pixels, + int* pitch + ) => ( - (delegate* unmanaged)( - _slots[486] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[685] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[486] = nativeContext.LoadFunction("SDL_HasLSX", "SDL3") + : _slots[685] = nativeContext.LoadFunction("SDL_LockTexture", "SDL3") ) - )(); + )(texture, rect, pixels, pitch); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasLSX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasLSXRaw() => DllImport.HasLSXRaw(); + public static byte LockTexture( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + void** pixels, + int* pitch + ) => DllImport.LockTexture(texture, rect, pixels, pitch); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasMMX() => (MaybeBool)(byte)((ISdl)this).HasMMXRaw(); + MaybeBool ISdl.LockTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D pixels, + Ref pitch + ) + { + fixed (int* __dsl_pitch = pitch) + fixed (void** __dsl_pixels = pixels) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte) + ((ISdl)this).LockTexture(__dsl_texture, __dsl_rect, __dsl_pixels, __dsl_pitch); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasMMX() => DllImport.HasMMX(); + public static MaybeBool LockTexture( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D pixels, + Ref pitch + ) => DllImport.LockTexture(texture, rect, pixels, pitch); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasMMXRaw() => + byte ISdl.LockTextureToSurface( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + Surface** surface + ) => ( - (delegate* unmanaged)( - _slots[487] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[686] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[487] = nativeContext.LoadFunction("SDL_HasMMX", "SDL3") + : _slots[686] = nativeContext.LoadFunction("SDL_LockTextureToSurface", "SDL3") ) - )(); + )(texture, rect, surface); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMMX")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasMMXRaw() => DllImport.HasMMXRaw(); + public static byte LockTextureToSurface( + Texture* texture, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + Surface** surface + ) => DllImport.LockTextureToSurface(texture, rect, surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasMouse() => (MaybeBool)(byte)((ISdl)this).HasMouseRaw(); + MaybeBool ISdl.LockTextureToSurface( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D surface + ) + { + fixed (Surface** __dsl_surface = surface) + fixed (Rect* __dsl_rect = rect) + fixed (Texture* __dsl_texture = texture) + { + return (MaybeBool) + (byte)((ISdl)this).LockTextureToSurface(__dsl_texture, __dsl_rect, __dsl_surface); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] + [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasMouse() => DllImport.HasMouse(); + public static MaybeBool LockTextureToSurface( + Ref texture, + [NativeTypeName("const SDL_Rect *")] Ref rect, + Ref2D surface + ) => DllImport.LockTextureToSurface(texture, rect, surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasMouseRaw() => + double ISdl.Log(double x) => ( - (delegate* unmanaged)( - _slots[488] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[687] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[488] = nativeContext.LoadFunction("SDL_HasMouse", "SDL3") + : _slots[687] = nativeContext.LoadFunction("SDL_log", "SDL3") ) - )(); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasMouse")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasMouseRaw() => DllImport.HasMouseRaw(); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasNeon() => (MaybeBool)(byte)((ISdl)this).HasNeonRaw(); + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_log")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasNeon() => DllImport.HasNeon(); + public static double Log(double x) => DllImport.Log(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasNeonRaw() => + double ISdl.Log10(double x) => ( - (delegate* unmanaged)( - _slots[489] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[688] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[489] = nativeContext.LoadFunction("SDL_HasNEON", "SDL3") + : _slots[688] = nativeContext.LoadFunction("SDL_log10", "SDL3") ) - )(); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasNEON")] + [NativeFunction("SDL3", EntryPoint = "SDL_log10")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasNeonRaw() => DllImport.HasNeonRaw(); + public static double Log10(double x) => DllImport.Log10(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasPrimarySelectionText() => - (MaybeBool)(byte)((ISdl)this).HasPrimarySelectionTextRaw(); + float ISdl.Log10F(float x) => + ( + (delegate* unmanaged)( + _slots[689] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[689] = nativeContext.LoadFunction("SDL_log10f", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_log10f")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasPrimarySelectionText() => DllImport.HasPrimarySelectionText(); + public static float Log10F(float x) => DllImport.Log10F(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasPrimarySelectionTextRaw() => + float ISdl.Logf(float x) => ( - (delegate* unmanaged)( - _slots[490] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[690] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[490] = nativeContext.LoadFunction( - "SDL_HasPrimarySelectionText", - "SDL3" - ) + : _slots[690] = nativeContext.LoadFunction("SDL_logf", "SDL3") ) - )(); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_logf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasPrimarySelectionTextRaw() => DllImport.HasPrimarySelectionTextRaw(); + public static float Logf(float x) => DllImport.Logf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name + void ISdl.LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap ) => ( - (delegate* unmanaged)( - _slots[491] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[691] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[491] = nativeContext.LoadFunction("SDL_HasProperty", "SDL3") + : _slots[691] = nativeContext.LoadFunction("SDL_LogMessageV", "SDL3") ) - )(props, name); + )(category, priority, fmt, ap); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.HasProperty(props, name); + public static void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.LogMessageV(category, priority, fmt, ap); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name + void ISdl.LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap ) { - fixed (sbyte* __dsl_name = name) + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) { - return (MaybeBool)(byte)((ISdl)this).HasProperty(props, __dsl_name); + ((ISdl)this).LogMessageV(category, priority, __dsl_fmt, __dsl_ap); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name - ) => DllImport.HasProperty(props, name); + public static void LogMessageV( + int category, + LogPriority priority, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.LogMessageV(category, priority, fmt, ap); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B - ) => + nint ISdl.Lround(double x) => ( - (delegate* unmanaged)( - _slots[492] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[692] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[492] = nativeContext.LoadFunction("SDL_HasRectIntersection", "SDL3") + : _slots[692] = nativeContext.LoadFunction("SDL_lround", "SDL3") ) - )(A, B); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lround")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Rect* A, - [NativeTypeName("const SDL_Rect *")] Rect* B - ) => DllImport.HasRectIntersection(A, B); + public static nint Lround(double x) => DllImport.Lround(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B - ) - { - fixed (Rect* __dsl_B = B) - fixed (Rect* __dsl_A = A) - { - return (MaybeBool)(byte)((ISdl)this).HasRectIntersection(__dsl_A, __dsl_B); - } - } + nint ISdl.Lroundf(float x) => + ( + (delegate* unmanaged)( + _slots[693] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[693] = nativeContext.LoadFunction("SDL_lroundf", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersection")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_lroundf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasRectIntersection( - [NativeTypeName("const SDL_Rect *")] Ref A, - [NativeTypeName("const SDL_Rect *")] Ref B - ) => DllImport.HasRectIntersection(A, B); + public static nint Lroundf(float x) => DllImport.Lroundf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B + sbyte* ISdl.Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix ) => ( - (delegate* unmanaged)( - _slots[493] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[694] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[493] = nativeContext.LoadFunction( - "SDL_HasRectIntersectionFloat", - "SDL3" - ) + : _slots[694] = nativeContext.LoadFunction("SDL_ltoa", "SDL3") ) - )(A, B); + )(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] FRect* A, - [NativeTypeName("const SDL_FRect *")] FRect* B - ) => DllImport.HasRectIntersectionFloat(A, B); + public static sbyte* Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => DllImport.Ltoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B + Ptr ISdl.Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix ) { - fixed (FRect* __dsl_B = B) - fixed (FRect* __dsl_A = A) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)((ISdl)this).HasRectIntersectionFloat(__dsl_A, __dsl_B); + return (sbyte*)((ISdl)this).Ltoa(value, __dsl_str, radix); } } - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasRectIntersectionFloat")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasRectIntersectionFloat( - [NativeTypeName("const SDL_FRect *")] Ref A, - [NativeTypeName("const SDL_FRect *")] Ref B - ) => DllImport.HasRectIntersectionFloat(A, B); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasScreenKeyboardSupport() => - (MaybeBool)(byte)((ISdl)this).HasScreenKeyboardSupportRaw(); - - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_ltoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasScreenKeyboardSupport() => - DllImport.HasScreenKeyboardSupport(); + public static Ptr Ltoa( + [NativeTypeName("long")] nint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Ltoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasScreenKeyboardSupportRaw() => + int ISdl.Main(int argc, [NativeTypeName("char *[]")] sbyte** argv) => ( - (delegate* unmanaged)( - _slots[494] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[695] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[494] = nativeContext.LoadFunction( - "SDL_HasScreenKeyboardSupport", - "SDL3" - ) + : _slots[695] = nativeContext.LoadFunction("SDL_main", "SDL3") ) - )(); + )(argc, argv); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasScreenKeyboardSupport")] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasScreenKeyboardSupportRaw() => DllImport.HasScreenKeyboardSupportRaw(); + public static int Main(int argc, [NativeTypeName("char *[]")] sbyte** argv) => + DllImport.Main(argc, argv); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasSSE() => (MaybeBool)(byte)((ISdl)this).HasSSERaw(); + int ISdl.Main(int argc, [NativeTypeName("char *[]")] Ref2D argv) + { + fixed (sbyte** __dsl_argv = argv) + { + return (int)((ISdl)this).Main(argc, __dsl_argv); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [NativeFunction("SDL3", EntryPoint = "SDL_main")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasSSE() => DllImport.HasSSE(); + public static int Main(int argc, [NativeTypeName("char *[]")] Ref2D argv) => + DllImport.Main(argc, argv); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasSSE2() => (MaybeBool)(byte)((ISdl)this).HasSSE2Raw(); + Ptr ISdl.Malloc([NativeTypeName("size_t")] nuint size) => (void*)((ISdl)this).MallocRaw(size); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasSSE2() => DllImport.HasSSE2(); + public static Ptr Malloc([NativeTypeName("size_t")] nuint size) => DllImport.Malloc(size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasSSE2Raw() => + void* ISdl.MallocRaw([NativeTypeName("size_t")] nuint size) => ( - (delegate* unmanaged)( - _slots[496] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[696] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[496] = nativeContext.LoadFunction("SDL_HasSSE2", "SDL3") + : _slots[696] = nativeContext.LoadFunction("SDL_malloc", "SDL3") ) - )(); + )(size); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE2")] + [NativeFunction("SDL3", EntryPoint = "SDL_malloc")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasSSE2Raw() => DllImport.HasSSE2Raw(); + public static void* MallocRaw([NativeTypeName("size_t")] nuint size) => + DllImport.MallocRaw(size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasSSE3() => (MaybeBool)(byte)((ISdl)this).HasSSE3Raw(); + void* ISdl.MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ) => + ( + (delegate* unmanaged)( + _slots[697] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[697] = nativeContext.LoadFunction("SDL_MapGPUTransferBuffer", "SDL3") + ) + )(device, transfer_buffer, cycle); + + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void* MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] byte cycle + ) => DllImport.MapGPUTransferBuffer(device, transfer_buffer, cycle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ) => (void*)((ISdl)this).MapGPUTransferBuffer(device, transfer_buffer, (byte)cycle); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapGPUTransferBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasSSE3() => DllImport.HasSSE3(); + public static Ptr MapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer, + [NativeTypeName("bool")] MaybeBool cycle + ) => DllImport.MapGPUTransferBuffer(device, transfer_buffer, cycle); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasSSE3Raw() => + uint ISdl.MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => ( - (delegate* unmanaged)( - _slots[497] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[698] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[497] = nativeContext.LoadFunction("SDL_HasSSE3", "SDL3") + : _slots[698] = nativeContext.LoadFunction("SDL_MapRGB", "SDL3") ) - )(); + )(format, palette, r, g, b); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE3")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasSSE3Raw() => DllImport.HasSSE3Raw(); + public static uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.MapRGB(format, palette, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasSSE41() => (MaybeBool)(byte)((ISdl)this).HasSSE41Raw(); + uint ISdl.MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + return (uint)((ISdl)this).MapRGB(__dsl_format, __dsl_palette, r, g, b); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasSSE41() => DllImport.HasSSE41(); + public static uint MapRGB( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.MapRGB(format, palette, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasSSE41Raw() => + uint ISdl.MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => ( - (delegate* unmanaged)( - _slots[498] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[699] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[498] = nativeContext.LoadFunction("SDL_HasSSE41", "SDL3") + : _slots[699] = nativeContext.LoadFunction("SDL_MapRGBA", "SDL3") ) - )(); + )(format, palette, r, g, b, a); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE41")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasSSE41Raw() => DllImport.HasSSE41Raw(); + public static uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, + [NativeTypeName("const SDL_Palette *")] Palette* palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.MapRgba(format, palette, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HasSSE42() => (MaybeBool)(byte)((ISdl)this).HasSSE42Raw(); + uint ISdl.MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Palette* __dsl_palette = palette) + fixed (PixelFormatDetails* __dsl_format = format) + { + return (uint)((ISdl)this).MapRgba(__dsl_format, __dsl_palette, r, g, b, a); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HasSSE42() => DllImport.HasSSE42(); + public static uint MapRgba( + [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, + [NativeTypeName("const SDL_Palette *")] Ref palette, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.MapRgba(format, palette, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasSSE42Raw() => + uint ISdl.MapSurfaceRGB( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => ( - (delegate* unmanaged)( - _slots[499] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[700] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[499] = nativeContext.LoadFunction("SDL_HasSSE42", "SDL3") + : _slots[700] = nativeContext.LoadFunction("SDL_MapSurfaceRGB", "SDL3") ) - )(); + )(surface, r, g, b); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE42")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasSSE42Raw() => DllImport.HasSSE42Raw(); + public static uint MapSurfaceRGB( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.MapSurfaceRGB(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HasSSERaw() => - ( - (delegate* unmanaged)( - _slots[495] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[495] = nativeContext.LoadFunction("SDL_HasSSE", "SDL3") - ) - )(); + uint ISdl.MapSurfaceRGB( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (uint)((ISdl)this).MapSurfaceRGB(__dsl_surface, r, g, b); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HasSSE")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HasSSERaw() => DllImport.HasSSERaw(); + public static uint MapSurfaceRGB( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.MapSurfaceRGB(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.HidBleScan([NativeTypeName("bool")] byte active) => + uint ISdl.MapSurfaceRgba( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => ( - (delegate* unmanaged)( - _slots[500] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[701] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[500] = nativeContext.LoadFunction("SDL_hid_ble_scan", "SDL3") + : _slots[701] = nativeContext.LoadFunction("SDL_MapSurfaceRGBA", "SDL3") ) - )(active); + )(surface, r, g, b, a); + + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint MapSurfaceRgba( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.MapSurfaceRgba(surface, r, g, b, a); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void HidBleScan([NativeTypeName("bool")] byte active) => - DllImport.HidBleScan(active); + uint ISdl.MapSurfaceRgba( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (uint)((ISdl)this).MapSurfaceRgba(__dsl_surface, r, g, b, a); + } + } + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.HidBleScan([NativeTypeName("bool")] MaybeBool active) => - ((ISdl)this).HidBleScan((byte)active); + public static uint MapSurfaceRgba( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.MapSurfaceRgba(surface, r, g, b, a); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.MaximizeWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).MaximizeWindowRaw(window); + + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_ble_scan")] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void HidBleScan([NativeTypeName("bool")] MaybeBool active) => - DllImport.HidBleScan(active); + public static MaybeBool MaximizeWindow(WindowHandle window) => + DllImport.MaximizeWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidClose(HidDeviceHandle dev) => + byte ISdl.MaximizeWindowRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[501] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[702] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[501] = nativeContext.LoadFunction("SDL_hid_close", "SDL3") + : _slots[702] = nativeContext.LoadFunction("SDL_MaximizeWindow", "SDL3") ) - )(dev); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_close")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidClose(HidDeviceHandle dev) => DllImport.HidClose(dev); + public static byte MaximizeWindowRaw(WindowHandle window) => + DllImport.MaximizeWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.HidDeviceChangeCount() => + int ISdl.Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ) => ( - (delegate* unmanaged)( - _slots[502] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[703] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[502] = nativeContext.LoadFunction( - "SDL_hid_device_change_count", - "SDL3" - ) + : _slots[703] = nativeContext.LoadFunction("SDL_memcmp", "SDL3") ) - )(); + )(s1, s2, len); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_device_change_count")] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint HidDeviceChangeCount() => DllImport.HidDeviceChangeCount(); + public static int Memcmp( + [NativeTypeName("const void *")] void* s1, + [NativeTypeName("const void *")] void* s2, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Memcmp(s1, s2, len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.HidEnumerate( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => (HidDeviceInfo*)((ISdl)this).HidEnumerateRaw(vendor_id, product_id); + int ISdl.Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ) + { + fixed (void* __dsl_s2 = s2) + fixed (void* __dsl_s1 = s1) + { + return (int)((ISdl)this).Memcmp(__dsl_s1, __dsl_s2, len); + } + } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [NativeFunction("SDL3", EntryPoint = "SDL_memcmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr HidEnumerate( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => DllImport.HidEnumerate(vendor_id, product_id); + public static int Memcmp( + [NativeTypeName("const void *")] Ref s1, + [NativeTypeName("const void *")] Ref s2, + [NativeTypeName("size_t")] nuint len + ) => DllImport.Memcmp(s1, s2, len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceInfo* ISdl.HidEnumerateRaw( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => + void ISdl.MemoryBarrierAcquireFunction() => ( - (delegate* unmanaged)( - _slots[503] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[704] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[503] = nativeContext.LoadFunction("SDL_hid_enumerate", "SDL3") + : _slots[704] = nativeContext.LoadFunction( + "SDL_MemoryBarrierAcquireFunction", + "SDL3" + ) ) - )(vendor_id, product_id); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_enumerate")] + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceInfo* HidEnumerateRaw( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id - ) => DllImport.HidEnumerateRaw(vendor_id, product_id); + public static void MemoryBarrierAcquireFunction() => DllImport.MemoryBarrierAcquireFunction(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidExit() => + void ISdl.MemoryBarrierReleaseFunction() => ( - (delegate* unmanaged)( - _slots[504] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[705] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[504] = nativeContext.LoadFunction("SDL_hid_exit", "SDL3") + : _slots[705] = nativeContext.LoadFunction( + "SDL_MemoryBarrierReleaseFunction", + "SDL3" + ) ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_exit")] + [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidExit() => DllImport.HidExit(); + public static void MemoryBarrierReleaseFunction() => DllImport.MemoryBarrierReleaseFunction(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.HidFreeEnumeration(HidDeviceInfo* devs) => + void* ISdl.Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => ( - (delegate* unmanaged)( - _slots[505] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[706] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[505] = nativeContext.LoadFunction("SDL_hid_free_enumeration", "SDL3") + : _slots[706] = nativeContext.LoadFunction("SDL_memset4", "SDL3") ) - )(devs); + )(dst, val, dwords); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void HidFreeEnumeration(HidDeviceInfo* devs) => - DllImport.HidFreeEnumeration(devs); + public static void* Memset4( + void* dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => DllImport.Memset4(dst, val, dwords); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.HidFreeEnumeration(Ref devs) + Ptr ISdl.Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) { - fixed (HidDeviceInfo* __dsl_devs = devs) + fixed (void* __dsl_dst = dst) { - ((ISdl)this).HidFreeEnumeration(__dsl_devs); + return (void*)((ISdl)this).Memset4(__dsl_dst, val, dwords); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_free_enumeration")] + [NativeFunction("SDL3", EntryPoint = "SDL_memset4")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void HidFreeEnumeration(Ref devs) => - DllImport.HidFreeEnumeration(devs); + public static Ptr Memset4( + Ref dst, + [NativeTypeName("Uint32")] uint val, + [NativeTypeName("size_t")] nuint dwords + ) => DllImport.Memset4(dst, val, dwords); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.HidGetDeviceInfo(HidDeviceHandle dev) => - (HidDeviceInfo*)((ISdl)this).HidGetDeviceInfoRaw(dev); + Ptr ISdl.MetalCreateView(WindowHandle window) => (void*)((ISdl)this).MetalCreateViewRaw(window); + [return: NativeTypeName("SDL_MetalView")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr HidGetDeviceInfo(HidDeviceHandle dev) => - DllImport.HidGetDeviceInfo(dev); + public static Ptr MetalCreateView(WindowHandle window) => DllImport.MetalCreateView(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceInfo* ISdl.HidGetDeviceInfoRaw(HidDeviceHandle dev) => + void* ISdl.MetalCreateViewRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[506] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[707] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[506] = nativeContext.LoadFunction("SDL_hid_get_device_info", "SDL3") + : _slots[707] = nativeContext.LoadFunction("SDL_Metal_CreateView", "SDL3") ) - )(dev); + )(window); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_device_info")] + [return: NativeTypeName("SDL_MetalView")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceInfo* HidGetDeviceInfoRaw(HidDeviceHandle dev) => - DllImport.HidGetDeviceInfoRaw(dev); + public static void* MetalCreateViewRaw(WindowHandle window) => + DllImport.MetalCreateViewRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => + void ISdl.MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => ( - (delegate* unmanaged)( - _slots[507] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[708] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[507] = nativeContext.LoadFunction("SDL_hid_get_feature_report", "SDL3") + : _slots[708] = nativeContext.LoadFunction("SDL_Metal_DestroyView", "SDL3") ) - )(dev, data, length); + )(view); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidGetFeatureReport(dev, data, length); + public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => + DllImport.MetalDestroyView(view); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) + void ISdl.MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) { - fixed (byte* __dsl_data = data) + fixed (void* __dsl_view = view) { - return (int)((ISdl)this).HidGetFeatureReport(dev, __dsl_data, length); + ((ISdl)this).MetalDestroyView(__dsl_view); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidGetFeatureReport(dev, data, length); + public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) => + DllImport.MetalDestroyView(view); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => + void* ISdl.MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => ( - (delegate* unmanaged)( - _slots[508] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[709] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[508] = nativeContext.LoadFunction("SDL_hid_get_indexed_string", "SDL3") + : _slots[709] = nativeContext.LoadFunction("SDL_Metal_GetLayer", "SDL3") ) - )(dev, string_index, @string, maxlen); + )(view); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetIndexedString(dev, string_index, @string, maxlen); + public static void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => + DllImport.MetalGetLayer(view); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + Ptr ISdl.MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) { - fixed (uint* __dsl_string = @string) + fixed (void* __dsl_view = view) { - return (int)((ISdl)this).HidGetIndexedString(dev, string_index, __dsl_string, maxlen); + return (void*)((ISdl)this).MetalGetLayer(__dsl_view); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_indexed_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetIndexedString( - HidDeviceHandle dev, - int string_index, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetIndexedString(dev, string_index, @string, maxlen); + public static Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) => + DllImport.MetalGetLayer(view); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length + MaybeBool ISdl.MinimizeWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).MinimizeWindowRaw(window); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool MinimizeWindow(WindowHandle window) => + DllImport.MinimizeWindow(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.MinimizeWindowRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[710] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[710] = nativeContext.LoadFunction("SDL_MinimizeWindow", "SDL3") + ) + )(window); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte MinimizeWindowRaw(WindowHandle window) => + DllImport.MinimizeWindowRaw(window); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.MixAudio( + [NativeTypeName("Uint8 *")] byte* dst, + [NativeTypeName("const Uint8 *")] byte* src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume ) => ( - (delegate* unmanaged)( - _slots[509] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[711] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[509] = nativeContext.LoadFunction("SDL_hid_get_input_report", "SDL3") + : _slots[711] = nativeContext.LoadFunction("SDL_MixAudio", "SDL3") ) - )(dev, data, length); + )(dst, src, format, len, volume); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidGetInputReport(dev, data, length); + public static byte MixAudio( + [NativeTypeName("Uint8 *")] byte* dst, + [NativeTypeName("const Uint8 *")] byte* src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) => DllImport.MixAudio(dst, src, format, len, volume); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length + MaybeBool ISdl.MixAudio( + [NativeTypeName("Uint8 *")] Ref dst, + [NativeTypeName("const Uint8 *")] Ref src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume ) { - fixed (byte* __dsl_data = data) + fixed (byte* __dsl_src = src) + fixed (byte* __dsl_dst = dst) { - return (int)((ISdl)this).HidGetInputReport(dev, __dsl_data, length); + return (MaybeBool) + (byte)((ISdl)this).MixAudio(__dsl_dst, __dsl_src, format, len, volume); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_input_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetInputReport( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidGetInputReport(dev, data, length); + public static MaybeBool MixAudio( + [NativeTypeName("Uint8 *")] Ref dst, + [NativeTypeName("const Uint8 *")] Ref src, + AudioFormat format, + [NativeTypeName("Uint32")] uint len, + float volume + ) => DllImport.MixAudio(dst, src, format, len, volume); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => + double ISdl.Modf(double x, double* y) => ( - (delegate* unmanaged)( - _slots[510] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[712] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[510] = nativeContext.LoadFunction( - "SDL_hid_get_manufacturer_string", - "SDL3" - ) + : _slots[712] = nativeContext.LoadFunction("SDL_modf", "SDL3") ) - )(dev, @string, maxlen); + )(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetManufacturerString(dev, @string, maxlen); + public static double Modf(double x, double* y) => DllImport.Modf(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + double ISdl.Modf(double x, Ref y) { - fixed (uint* __dsl_string = @string) + fixed (double* __dsl_y = y) { - return (int)((ISdl)this).HidGetManufacturerString(dev, __dsl_string, maxlen); + return (double)((ISdl)this).Modf(x, __dsl_y); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_manufacturer_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_modf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetManufacturerString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetManufacturerString(dev, @string, maxlen); + public static double Modf(double x, Ref y) => DllImport.Modf(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => + float ISdl.Modff(float x, float* y) => ( - (delegate* unmanaged)( - _slots[511] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[713] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[511] = nativeContext.LoadFunction("SDL_hid_get_product_string", "SDL3") + : _slots[713] = nativeContext.LoadFunction("SDL_modff", "SDL3") ) - )(dev, @string, maxlen); + )(x, y); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetProductString(dev, @string, maxlen); + public static float Modff(float x, float* y) => DllImport.Modff(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) + float ISdl.Modff(float x, Ref y) { - fixed (uint* __dsl_string = @string) + fixed (float* __dsl_y = y) { - return (int)((ISdl)this).HidGetProductString(dev, __dsl_string, maxlen); + return (float)((ISdl)this).Modff(x, __dsl_y); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_product_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_modff")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetProductString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetProductString(dev, @string, maxlen); + public static float Modff(float x, Ref y) => DllImport.Modff(x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* buf, - [NativeTypeName("size_t")] nuint buf_size + uint ISdl.Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed ) => ( - (delegate* unmanaged)( - _slots[512] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[714] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[512] = nativeContext.LoadFunction( - "SDL_hid_get_report_descriptor", - "SDL3" - ) + : _slots[714] = nativeContext.LoadFunction("SDL_murmur3_32", "SDL3") ) - )(dev, buf, buf_size); + )(data, len, seed); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* buf, - [NativeTypeName("size_t")] nuint buf_size - ) => DllImport.HidGetReportDescriptor(dev, buf, buf_size); + public static uint Murmur3X32( + [NativeTypeName("const void *")] void* data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) => DllImport.Murmur3X32(data, len, seed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref buf, - [NativeTypeName("size_t")] nuint buf_size + uint ISdl.Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed ) { - fixed (byte* __dsl_buf = buf) + fixed (void* __dsl_data = data) { - return (int)((ISdl)this).HidGetReportDescriptor(dev, __dsl_buf, buf_size); + return (uint)((ISdl)this).Murmur3X32(__dsl_data, len, seed); } } + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_report_descriptor")] + [NativeFunction("SDL3", EntryPoint = "SDL_murmur3_32")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetReportDescriptor( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref buf, - [NativeTypeName("size_t")] nuint buf_size - ) => DllImport.HidGetReportDescriptor(dev, buf, buf_size); + public static uint Murmur3X32( + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("size_t")] nuint len, + [NativeTypeName("Uint32")] uint seed + ) => DllImport.Murmur3X32(data, len, seed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => + void ISdl.OnApplicationDidEnterBackground() => ( - (delegate* unmanaged)( - _slots[513] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[715] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[513] = nativeContext.LoadFunction( - "SDL_hid_get_serial_number_string", + : _slots[715] = nativeContext.LoadFunction( + "SDL_OnApplicationDidEnterBackground", "SDL3" ) ) - )(dev, @string, maxlen); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] uint* @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetSerialNumberString(dev, @string, maxlen); + public static void OnApplicationDidEnterBackground() => + DllImport.OnApplicationDidEnterBackground(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) - { - fixed (uint* __dsl_string = @string) - { - return (int)((ISdl)this).HidGetSerialNumberString(dev, __dsl_string, maxlen); - } - } + void ISdl.OnApplicationDidEnterForeground() => + ( + (delegate* unmanaged)( + _slots[716] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[716] = nativeContext.LoadFunction( + "SDL_OnApplicationDidEnterForeground", + "SDL3" + ) + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_get_serial_number_string")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidGetSerialNumberString( - HidDeviceHandle dev, - [NativeTypeName("wchar_t *")] Ref @string, - [NativeTypeName("size_t")] nuint maxlen - ) => DllImport.HidGetSerialNumberString(dev, @string, maxlen); + public static void OnApplicationDidEnterForeground() => + DllImport.OnApplicationDidEnterForeground(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidInit() => + void ISdl.OnApplicationDidReceiveMemoryWarning() => ( - (delegate* unmanaged)( - _slots[514] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[717] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[717] = nativeContext.LoadFunction( + "SDL_OnApplicationDidReceiveMemoryWarning", + "SDL3" + ) + ) + )(); + + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void OnApplicationDidReceiveMemoryWarning() => + DllImport.OnApplicationDidReceiveMemoryWarning(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.OnApplicationWillEnterBackground() => + ( + (delegate* unmanaged)( + _slots[718] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[514] = nativeContext.LoadFunction("SDL_hid_init", "SDL3") + : _slots[718] = nativeContext.LoadFunction( + "SDL_OnApplicationWillEnterBackground", + "SDL3" + ) ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_init")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidInit() => DllImport.HidInit(); + public static void OnApplicationWillEnterBackground() => + DllImport.OnApplicationWillEnterBackground(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceHandle ISdl.HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] uint* serial_number - ) => + void ISdl.OnApplicationWillEnterForeground() => ( - (delegate* unmanaged)( - _slots[515] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[719] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[515] = nativeContext.LoadFunction("SDL_hid_open", "SDL3") + : _slots[719] = nativeContext.LoadFunction( + "SDL_OnApplicationWillEnterForeground", + "SDL3" + ) ) - )(vendor_id, product_id, serial_number); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] uint* serial_number - ) => DllImport.HidOpen(vendor_id, product_id, serial_number); + public static void OnApplicationWillEnterForeground() => + DllImport.OnApplicationWillEnterForeground(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceHandle ISdl.HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] Ref serial_number - ) - { - fixed (uint* __dsl_serial_number = serial_number) - { - return (HidDeviceHandle) - ((ISdl)this).HidOpen(vendor_id, product_id, __dsl_serial_number); - } - } + void ISdl.OnApplicationWillTerminate() => + ( + (delegate* unmanaged)( + _slots[720] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[720] = nativeContext.LoadFunction( + "SDL_OnApplicationWillTerminate", + "SDL3" + ) + ) + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open")] + [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceHandle HidOpen( - [NativeTypeName("unsigned short")] ushort vendor_id, - [NativeTypeName("unsigned short")] ushort product_id, - [NativeTypeName("const wchar_t *")] Ref serial_number - ) => DllImport.HidOpen(vendor_id, product_id, serial_number); + public static void OnApplicationWillTerminate() => DllImport.OnApplicationWillTerminate(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceHandle ISdl.HidOpenPath([NativeTypeName("const char *")] sbyte* path) => + uint ISdl.OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec + ) => ( - (delegate* unmanaged)( - _slots[516] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[721] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[516] = nativeContext.LoadFunction("SDL_hid_open_path", "SDL3") + : _slots[721] = nativeContext.LoadFunction("SDL_OpenAudioDevice", "SDL3") ) - )(path); + )(devid, spec); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [return: NativeTypeName("SDL_AudioDeviceID")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] sbyte* path) => - DllImport.HidOpenPath(path); + public static uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec + ) => DllImport.OpenAudioDevice(devid, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HidDeviceHandle ISdl.HidOpenPath([NativeTypeName("const char *")] Ref path) + uint ISdl.OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec + ) { - fixed (sbyte* __dsl_path = path) + fixed (AudioSpec* __dsl_spec = spec) { - return (HidDeviceHandle)((ISdl)this).HidOpenPath(__dsl_path); + return (uint)((ISdl)this).OpenAudioDevice(devid, __dsl_spec); } } + [return: NativeTypeName("SDL_AudioDeviceID")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_open_path")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HidDeviceHandle HidOpenPath([NativeTypeName("const char *")] Ref path) => - DllImport.HidOpenPath(path); + public static uint OpenAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec + ) => DllImport.OpenAudioDevice(devid, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length + AudioStreamHandle ISdl.OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[517] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[722] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[517] = nativeContext.LoadFunction("SDL_hid_read", "SDL3") + : _slots[722] = nativeContext.LoadFunction("SDL_OpenAudioDeviceStream", "SDL3") ) - )(dev, data, length); + )(devid, spec, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidRead(dev, data, length); + public static AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => DllImport.OpenAudioDeviceStream(devid, spec, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length + AudioStreamHandle ISdl.OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata ) { - fixed (byte* __dsl_data = data) + fixed (void* __dsl_userdata = userdata) + fixed (AudioSpec* __dsl_spec = spec) { - return (int)((ISdl)this).HidRead(dev, __dsl_data, length); + return (AudioStreamHandle) + ((ISdl)this).OpenAudioDeviceStream(devid, __dsl_spec, callback, __dsl_userdata); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidRead( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidRead(dev, data, length); + public static AudioStreamHandle OpenAudioDeviceStream( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("const SDL_AudioSpec *")] Ref spec, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) => DllImport.OpenAudioDeviceStream(devid, spec, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length, - int milliseconds + CameraHandle ISdl.OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec ) => ( - (delegate* unmanaged)( - _slots[518] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[723] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[518] = nativeContext.LoadFunction("SDL_hid_read_timeout", "SDL3") + : _slots[723] = nativeContext.LoadFunction("SDL_OpenCamera", "SDL3") ) - )(dev, data, length, milliseconds); + )(instance_id, spec); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) => DllImport.HidReadTimeout(dev, data, length, milliseconds); + public static CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec + ) => DllImport.OpenCamera(instance_id, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length, - int milliseconds + CameraHandle ISdl.OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] Ref spec ) { - fixed (byte* __dsl_data = data) + fixed (CameraSpec* __dsl_spec = spec) { - return (int)((ISdl)this).HidReadTimeout(dev, __dsl_data, length, milliseconds); + return (CameraHandle)((ISdl)this).OpenCamera(instance_id, __dsl_spec); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_read_timeout")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidReadTimeout( - HidDeviceHandle dev, - [NativeTypeName("unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length, - int milliseconds - ) => DllImport.HidReadTimeout(dev, data, length, milliseconds); + public static CameraHandle OpenCamera( + [NativeTypeName("SDL_CameraID")] uint instance_id, + [NativeTypeName("const SDL_CameraSpec *")] Ref spec + ) => DllImport.OpenCamera(instance_id, spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => + StorageHandle ISdl.OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => ( - (delegate* unmanaged)( - _slots[519] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[724] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[519] = nativeContext.LoadFunction( - "SDL_hid_send_feature_report", - "SDL3" - ) + : _slots[724] = nativeContext.LoadFunction("SDL_OpenFileStorage", "SDL3") ) - )(dev, data, length); + )(path); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidSendFeatureReport(dev, data, length); + public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => + DllImport.OpenFileStorage(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) + StorageHandle ISdl.OpenFileStorage([NativeTypeName("const char *")] Ref path) { - fixed (byte* __dsl_data = data) + fixed (sbyte* __dsl_path = path) { - return (int)((ISdl)this).HidSendFeatureReport(dev, __dsl_data, length); + return (StorageHandle)((ISdl)this).OpenFileStorage(__dsl_path); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_send_feature_report")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidSendFeatureReport( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidSendFeatureReport(dev, data, length); + public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] Ref path) => + DllImport.OpenFileStorage(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidSetNonblocking(HidDeviceHandle dev, int nonblock) => + GamepadHandle ISdl.OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[520] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[725] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[520] = nativeContext.LoadFunction("SDL_hid_set_nonblocking", "SDL3") + : _slots[725] = nativeContext.LoadFunction("SDL_OpenGamepad", "SDL3") ) - )(dev, nonblock); + )(instance_id); - [NativeFunction("SDL3", EntryPoint = "SDL_hid_set_nonblocking")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidSetNonblocking(HidDeviceHandle dev, int nonblock) => - DllImport.HidSetNonblocking(dev, nonblock); + public static GamepadHandle OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => + DllImport.OpenGamepad(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => + HapticHandle ISdl.OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[521] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[726] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[521] = nativeContext.LoadFunction("SDL_hid_write", "SDL3") + : _slots[726] = nativeContext.LoadFunction("SDL_OpenHaptic", "SDL3") ) - )(dev, data, length); - - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] byte* data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidWrite(dev, data, length); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) - { - fixed (byte* __dsl_data = data) - { - return (int)((ISdl)this).HidWrite(dev, __dsl_data, length); - } - } + )(instance_id); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_hid_write")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int HidWrite( - HidDeviceHandle dev, - [NativeTypeName("const unsigned char *")] Ref data, - [NativeTypeName("size_t")] nuint length - ) => DllImport.HidWrite(dev, data, length); + public static HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => + DllImport.OpenHaptic(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HideCursor() => (MaybeBool)(byte)((ISdl)this).HideCursorRaw(); + HapticHandle ISdl.OpenHapticFromJoystick(JoystickHandle joystick) => + ( + (delegate* unmanaged)( + _slots[727] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[727] = nativeContext.LoadFunction("SDL_OpenHapticFromJoystick", "SDL3") + ) + )(joystick); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HideCursor() => DllImport.HideCursor(); + public static HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => + DllImport.OpenHapticFromJoystick(joystick); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HideCursorRaw() => + HapticHandle ISdl.OpenHapticFromMouse() => ( - (delegate* unmanaged)( - _slots[522] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[728] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[522] = nativeContext.LoadFunction("SDL_HideCursor", "SDL3") + : _slots[728] = nativeContext.LoadFunction("SDL_OpenHapticFromMouse", "SDL3") ) )(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideCursor")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HideCursorRaw() => DllImport.HideCursorRaw(); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.HideWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).HideWindowRaw(window); - - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool HideWindow(WindowHandle window) => DllImport.HideWindow(window); + public static HapticHandle OpenHapticFromMouse() => DllImport.OpenHapticFromMouse(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.HideWindowRaw(WindowHandle window) => + IOStreamHandle ISdl.OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, + void* userdata + ) => ( - (delegate* unmanaged)( - _slots[523] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[729] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[523] = nativeContext.LoadFunction("SDL_HideWindow", "SDL3") + : _slots[729] = nativeContext.LoadFunction("SDL_OpenIO", "SDL3") ) - )(window); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_HideWindow")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte HideWindowRaw(WindowHandle window) => DllImport.HideWindowRaw(window); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.Init([NativeTypeName("SDL_InitFlags")] uint flags) => - (MaybeBool)(byte)((ISdl)this).InitRaw(flags); + )(iface, userdata); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool Init([NativeTypeName("SDL_InitFlags")] uint flags) => - DllImport.Init(flags); + public static IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, + void* userdata + ) => DllImport.OpenIO(iface, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.InitHapticRumble(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).InitHapticRumbleRaw(haptic); + IOStreamHandle ISdl.OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (IOStreamInterface* __dsl_iface = iface) + { + return (IOStreamHandle)((ISdl)this).OpenIO(__dsl_iface, __dsl_userdata); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool InitHapticRumble(HapticHandle haptic) => - DllImport.InitHapticRumble(haptic); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.InitHapticRumbleRaw(HapticHandle haptic) => - ( - (delegate* unmanaged)( - _slots[525] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[525] = nativeContext.LoadFunction("SDL_InitHapticRumble", "SDL3") - ) - )(haptic); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte InitHapticRumbleRaw(HapticHandle haptic) => - DllImport.InitHapticRumbleRaw(haptic); + public static IOStreamHandle OpenIO( + [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, + Ref userdata + ) => DllImport.OpenIO(iface, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + JoystickHandle ISdl.OpenJoystick([NativeTypeName("SDL_JoystickID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[524] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[730] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[524] = nativeContext.LoadFunction("SDL_Init", "SDL3") + : _slots[730] = nativeContext.LoadFunction("SDL_OpenJoystick", "SDL3") ) - )(flags); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_Init")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte InitRaw([NativeTypeName("SDL_InitFlags")] uint flags) => - DllImport.InitRaw(flags); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - (MaybeBool)(byte)((ISdl)this).InitSubSystemRaw(flags); + )(instance_id); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool InitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - DllImport.InitSubSystem(flags); + public static JoystickHandle OpenJoystick( + [NativeTypeName("SDL_JoystickID")] uint instance_id + ) => DllImport.OpenJoystick(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => + SensorHandle ISdl.OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => ( - (delegate* unmanaged)( - _slots[526] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[731] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[526] = nativeContext.LoadFunction("SDL_InitSubSystem", "SDL3") + : _slots[731] = nativeContext.LoadFunction("SDL_OpenSensor", "SDL3") ) - )(flags); + )(instance_id); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_InitSubSystem")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte InitSubSystemRaw([NativeTypeName("SDL_InitFlags")] uint flags) => - DllImport.InitSubSystemRaw(flags); + public static SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => + DllImport.OpenSensor(instance_id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromConstMem( - [NativeTypeName("const void *")] void* mem, - [NativeTypeName("size_t")] nuint size + StorageHandle ISdl.OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[527] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[732] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[527] = nativeContext.LoadFunction("SDL_IOFromConstMem", "SDL3") + : _slots[732] = nativeContext.LoadFunction("SDL_OpenStorage", "SDL3") ) - )(mem, size); + )(iface, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] void* mem, - [NativeTypeName("size_t")] nuint size - ) => DllImport.IOFromConstMem(mem, size); + public static StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, + void* userdata + ) => DllImport.OpenStorage(iface, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromConstMem( - [NativeTypeName("const void *")] Ref mem, - [NativeTypeName("size_t")] nuint size + StorageHandle ISdl.OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] Ref iface, + Ref userdata ) { - fixed (void* __dsl_mem = mem) + fixed (void* __dsl_userdata = userdata) + fixed (StorageInterface* __dsl_iface = iface) { - return (IOStreamHandle)((ISdl)this).IOFromConstMem(__dsl_mem, size); + return (StorageHandle)((ISdl)this).OpenStorage(__dsl_iface, __dsl_userdata); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromConstMem")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromConstMem( - [NativeTypeName("const void *")] Ref mem, - [NativeTypeName("size_t")] nuint size - ) => DllImport.IOFromConstMem(mem, size); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromDynamicMem() => - ( - (delegate* unmanaged)( - _slots[528] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[528] = nativeContext.LoadFunction("SDL_IOFromDynamicMem", "SDL3") - ) - )(); - - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromDynamicMem")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromDynamicMem() => DllImport.IOFromDynamicMem(); + public static StorageHandle OpenStorage( + [NativeTypeName("const SDL_StorageInterface *")] Ref iface, + Ref userdata + ) => DllImport.OpenStorage(iface, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("const char *")] sbyte* mode + StorageHandle ISdl.OpenTitleStorage( + [NativeTypeName("const char *")] sbyte* @override, + [NativeTypeName("SDL_PropertiesID")] uint props ) => ( - (delegate* unmanaged)( - _slots[529] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[733] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[529] = nativeContext.LoadFunction("SDL_IOFromFile", "SDL3") + : _slots[733] = nativeContext.LoadFunction("SDL_OpenTitleStorage", "SDL3") ) - )(file, mode); + )(@override, props); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("const char *")] sbyte* mode - ) => DllImport.IOFromFile(file, mode); + public static StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] sbyte* @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.OpenTitleStorage(@override, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("const char *")] Ref mode + StorageHandle ISdl.OpenTitleStorage( + [NativeTypeName("const char *")] Ref @override, + [NativeTypeName("SDL_PropertiesID")] uint props ) { - fixed (sbyte* __dsl_mode = mode) - fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_override = @override) { - return (IOStreamHandle)((ISdl)this).IOFromFile(__dsl_file, __dsl_mode); + return (StorageHandle)((ISdl)this).OpenTitleStorage(__dsl_override, props); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("const char *")] Ref mode - ) => DllImport.IOFromFile(file, mode); + public static StorageHandle OpenTitleStorage( + [NativeTypeName("const char *")] Ref @override, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.OpenTitleStorage(@override, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => + byte ISdl.OpenURL([NativeTypeName("const char *")] sbyte* url) => ( - (delegate* unmanaged)( - _slots[530] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[734] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[530] = nativeContext.LoadFunction("SDL_IOFromMem", "SDL3") + : _slots[734] = nativeContext.LoadFunction("SDL_OpenURL", "SDL3") ) - )(mem, size); + )(url); - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromMem(void* mem, [NativeTypeName("size_t")] nuint size) => - DllImport.IOFromMem(mem, size); + public static byte OpenURL([NativeTypeName("const char *")] sbyte* url) => + DllImport.OpenURL(url); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) + MaybeBool ISdl.OpenURL([NativeTypeName("const char *")] Ref url) { - fixed (void* __dsl_mem = mem) + fixed (sbyte* __dsl_url = url) { - return (IOStreamHandle)((ISdl)this).IOFromMem(__dsl_mem, size); + return (MaybeBool)(byte)((ISdl)this).OpenURL(__dsl_url); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOFromMem")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle IOFromMem(Ref mem, [NativeTypeName("size_t")] nuint size) => - DllImport.IOFromMem(mem, size); + public static MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) => + DllImport.OpenURL(url); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - nuint ISdl.IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap + StorageHandle ISdl.OpenUserStorage( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app, + [NativeTypeName("SDL_PropertiesID")] uint props ) => ( - (delegate* unmanaged)( - _slots[531] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[735] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[531] = nativeContext.LoadFunction("SDL_IOvprintf", "SDL3") + : _slots[735] = nativeContext.LoadFunction("SDL_OpenUserStorage", "SDL3") ) - )(context, fmt, ap); + )(org, app, props); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => DllImport.IOvprintf(context, fmt, ap); + public static StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] sbyte* org, + [NativeTypeName("const char *")] sbyte* app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.OpenUserStorage(org, app, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - nuint ISdl.IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap + StorageHandle ISdl.OpenUserStorage( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app, + [NativeTypeName("SDL_PropertiesID")] uint props ) { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_app = app) + fixed (sbyte* __dsl_org = org) { - return (nuint)((ISdl)this).IOvprintf(context, __dsl_fmt, __dsl_ap); + return (StorageHandle)((ISdl)this).OpenUserStorage(__dsl_org, __dsl_app, props); } } - [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IOvprintf")] + [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static nuint IOvprintf( - IOStreamHandle context, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => DllImport.IOvprintf(context, fmt, ap); + public static StorageHandle OpenUserStorage( + [NativeTypeName("const char *")] Ref org, + [NativeTypeName("const char *")] Ref app, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.OpenUserStorage(org, app, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (MaybeBool)(byte)((ISdl)this).IsGamepadRaw(instance_id); + MaybeBool ISdl.OutOfMemory() => (MaybeBool)(byte)((ISdl)this).OutOfMemoryRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.IsGamepad(instance_id); + public static MaybeBool OutOfMemory() => DllImport.OutOfMemory(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + byte ISdl.OutOfMemoryRaw() => ( - (delegate* unmanaged)( - _slots[532] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[736] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[532] = nativeContext.LoadFunction("SDL_IsGamepad", "SDL3") + : _slots[736] = nativeContext.LoadFunction("SDL_OutOfMemory", "SDL3") ) - )(instance_id); + )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsGamepadRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.IsGamepadRaw(instance_id); + public static byte OutOfMemoryRaw() => DllImport.OutOfMemoryRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsJoystickHaptic(JoystickHandle joystick) => - (MaybeBool)(byte)((ISdl)this).IsJoystickHapticRaw(joystick); + MaybeBool ISdl.PauseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + (MaybeBool)(byte)((ISdl)this).PauseAudioDeviceRaw(dev); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsJoystickHaptic(JoystickHandle joystick) => - DllImport.IsJoystickHaptic(joystick); + public static MaybeBool PauseAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => DllImport.PauseAudioDevice(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsJoystickHapticRaw(JoystickHandle joystick) => + byte ISdl.PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => ( - (delegate* unmanaged)( - _slots[533] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[737] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[533] = nativeContext.LoadFunction("SDL_IsJoystickHaptic", "SDL3") + : _slots[737] = nativeContext.LoadFunction("SDL_PauseAudioDevice", "SDL3") ) - )(joystick); + )(dev); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsJoystickHapticRaw(JoystickHandle joystick) => - DllImport.IsJoystickHapticRaw(joystick); + public static byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + DllImport.PauseAudioDeviceRaw(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsJoystickVirtual([NativeTypeName("SDL_JoystickID")] uint instance_id) => - (MaybeBool)(byte)((ISdl)this).IsJoystickVirtualRaw(instance_id); + MaybeBool ISdl.PauseAudioStreamDevice(AudioStreamHandle stream) => + (MaybeBool)(byte)((ISdl)this).PauseAudioStreamDeviceRaw(stream); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsJoystickVirtual( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.IsJoystickVirtual(instance_id); + public static MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => + DllImport.PauseAudioStreamDevice(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => + byte ISdl.PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[534] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[738] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[534] = nativeContext.LoadFunction("SDL_IsJoystickVirtual", "SDL3") + : _slots[738] = nativeContext.LoadFunction("SDL_PauseAudioStreamDevice", "SDL3") ) - )(instance_id); + )(stream); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsJoystickVirtual")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsJoystickVirtualRaw([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.IsJoystickVirtualRaw(instance_id); + public static byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => + DllImport.PauseAudioStreamDeviceRaw(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsMouseHaptic() => (MaybeBool)(byte)((ISdl)this).IsMouseHapticRaw(); + MaybeBool ISdl.PauseHaptic(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).PauseHapticRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsMouseHaptic() => DllImport.IsMouseHaptic(); + public static MaybeBool PauseHaptic(HapticHandle haptic) => DllImport.PauseHaptic(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsMouseHapticRaw() => + byte ISdl.PauseHapticRaw(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[535] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[739] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[535] = nativeContext.LoadFunction("SDL_IsMouseHaptic", "SDL3") + : _slots[739] = nativeContext.LoadFunction("SDL_PauseHaptic", "SDL3") ) - )(); + )(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsMouseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsMouseHapticRaw() => DllImport.IsMouseHapticRaw(); + public static byte PauseHapticRaw(HapticHandle haptic) => DllImport.PauseHapticRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsTablet() => (MaybeBool)(byte)((ISdl)this).IsTabletRaw(); + int ISdl.PeepEvents( + Event* events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => + ( + (delegate* unmanaged)( + _slots[740] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[740] = nativeContext.LoadFunction("SDL_PeepEvents", "SDL3") + ) + )(events, numevents, action, minType, maxType); + + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int PeepEvents( + Event* events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => DllImport.PeepEvents(events, numevents, action, minType, maxType); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.PeepEvents( + Ref events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) + { + fixed (Event* __dsl_events = events) + { + return (int)((ISdl)this).PeepEvents(__dsl_events, numevents, action, minType, maxType); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int PeepEvents( + Ref events, + int numevents, + EventAction action, + [NativeTypeName("Uint32")] uint minType, + [NativeTypeName("Uint32")] uint maxType + ) => DllImport.PeepEvents(events, numevents, action, minType, maxType); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.PlayHapticRumble( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => (MaybeBool)(byte)((ISdl)this).PlayHapticRumbleRaw(haptic, strength, length); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsTablet() => DllImport.IsTablet(); + public static MaybeBool PlayHapticRumble( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PlayHapticRumble(haptic, strength, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsTabletRaw() => + byte ISdl.PlayHapticRumbleRaw( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => ( - (delegate* unmanaged)( - _slots[536] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[741] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[536] = nativeContext.LoadFunction("SDL_IsTablet", "SDL3") + : _slots[741] = nativeContext.LoadFunction("SDL_PlayHapticRumble", "SDL3") ) - )(); + )(haptic, strength, length); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTablet")] + [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsTabletRaw() => DllImport.IsTabletRaw(); + public static byte PlayHapticRumbleRaw( + HapticHandle haptic, + float strength, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PlayHapticRumbleRaw(haptic, strength, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.IsTV() => (MaybeBool)(byte)((ISdl)this).IsTVRaw(); + byte ISdl.PollEvent(Event* @event) => + ( + (delegate* unmanaged)( + _slots[742] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[742] = nativeContext.LoadFunction("SDL_PollEvent", "SDL3") + ) + )(@event); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte PollEvent(Event* @event) => DllImport.PollEvent(@event); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.PollEvent(Ref @event) + { + fixed (Event* __dsl_event = @event) + { + return (MaybeBool)(byte)((ISdl)this).PollEvent(__dsl_event); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool IsTV() => DllImport.IsTV(); + public static MaybeBool PollEvent(Ref @event) => DllImport.PollEvent(@event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.IsTVRaw() => + void ISdl.PopGPUDebugGroup(GPUCommandBufferHandle command_buffer) => ( - (delegate* unmanaged)( - _slots[537] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[743] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[537] = nativeContext.LoadFunction("SDL_IsTV", "SDL3") + : _slots[743] = nativeContext.LoadFunction("SDL_PopGPUDebugGroup", "SDL3") ) - )(); + )(command_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_PopGPUDebugGroup")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void PopGPUDebugGroup(GPUCommandBufferHandle command_buffer) => + DllImport.PopGPUDebugGroup(command_buffer); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Pow(double x, double y) => + ( + (delegate* unmanaged)( + _slots[744] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[744] = nativeContext.LoadFunction("SDL_pow", "SDL3") + ) + )(x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_pow")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Pow(double x, double y) => DllImport.Pow(x, y); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Powf(float x, float y) => + ( + (delegate* unmanaged)( + _slots[745] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[745] = nativeContext.LoadFunction("SDL_powf", "SDL3") + ) + )(x, y); + + [NativeFunction("SDL3", EntryPoint = "SDL_powf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Powf(float x, float y) => DllImport.Powf(x, y); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch, + [NativeTypeName("bool")] byte linear + ) => + ( + (delegate* unmanaged< + int, + int, + PixelFormat, + void*, + int, + PixelFormat, + void*, + int, + byte, + byte>)( + _slots[746] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[746] = nativeContext.LoadFunction("SDL_PremultiplyAlpha", "SDL3") + ) + )(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch, linear); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_IsTV")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte IsTVRaw() => DllImport.IsTVRaw(); + public static byte PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] void* src, + int src_pitch, + PixelFormat dst_format, + void* dst, + int dst_pitch, + [NativeTypeName("bool")] byte linear + ) => + DllImport.PremultiplyAlpha( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch, + linear + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.JoystickConnected(JoystickHandle joystick) => - (MaybeBool)(byte)((ISdl)this).JoystickConnectedRaw(joystick); + MaybeBool ISdl.PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch, + [NativeTypeName("bool")] MaybeBool linear + ) + { + fixed (void* __dsl_dst = dst) + fixed (void* __dsl_src = src) + { + return (MaybeBool) + (byte) + ((ISdl)this).PremultiplyAlpha( + width, + height, + src_format, + __dsl_src, + src_pitch, + dst_format, + __dsl_dst, + dst_pitch, + (byte)linear + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool JoystickConnected(JoystickHandle joystick) => - DllImport.JoystickConnected(joystick); + public static MaybeBool PremultiplyAlpha( + int width, + int height, + PixelFormat src_format, + [NativeTypeName("const void *")] Ref src, + int src_pitch, + PixelFormat dst_format, + Ref dst, + int dst_pitch, + [NativeTypeName("bool")] MaybeBool linear + ) => + DllImport.PremultiplyAlpha( + width, + height, + src_format, + src, + src_pitch, + dst_format, + dst, + dst_pitch, + linear + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.JoystickConnectedRaw(JoystickHandle joystick) => + byte ISdl.PremultiplySurfaceAlpha(Surface* surface, [NativeTypeName("bool")] byte linear) => ( - (delegate* unmanaged)( - _slots[538] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[747] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[538] = nativeContext.LoadFunction("SDL_JoystickConnected", "SDL3") + : _slots[747] = nativeContext.LoadFunction( + "SDL_PremultiplySurfaceAlpha", + "SDL3" + ) ) - )(joystick); + )(surface, linear); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickConnected")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte JoystickConnectedRaw(JoystickHandle joystick) => - DllImport.JoystickConnectedRaw(joystick); + public static byte PremultiplySurfaceAlpha( + Surface* surface, + [NativeTypeName("bool")] byte linear + ) => DllImport.PremultiplySurfaceAlpha(surface, linear); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.JoystickEventsEnabled() => - (MaybeBool)(byte)((ISdl)this).JoystickEventsEnabledRaw(); + MaybeBool ISdl.PremultiplySurfaceAlpha( + Ref surface, + [NativeTypeName("bool")] MaybeBool linear + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).PremultiplySurfaceAlpha(__dsl_surface, (byte)linear); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool JoystickEventsEnabled() => DllImport.JoystickEventsEnabled(); + public static MaybeBool PremultiplySurfaceAlpha( + Ref surface, + [NativeTypeName("bool")] MaybeBool linear + ) => DllImport.PremultiplySurfaceAlpha(surface, linear); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.JoystickEventsEnabledRaw() => + void ISdl.PumpEvents() => ( - (delegate* unmanaged)( - _slots[539] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[748] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[539] = nativeContext.LoadFunction("SDL_JoystickEventsEnabled", "SDL3") + : _slots[748] = nativeContext.LoadFunction("SDL_PumpEvents", "SDL3") ) )(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_JoystickEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte JoystickEventsEnabledRaw() => DllImport.JoystickEventsEnabledRaw(); + public static void PumpEvents() => DllImport.PumpEvents(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.LoadBMP([NativeTypeName("const char *")] sbyte* file) => - ( - (delegate* unmanaged)( - _slots[540] is not null and var loadedFnPtr + byte ISdl.PushEvent(Event* @event) => + ( + (delegate* unmanaged)( + _slots[749] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[540] = nativeContext.LoadFunction("SDL_LoadBMP", "SDL3") + : _slots[749] = nativeContext.LoadFunction("SDL_PushEvent", "SDL3") ) - )(file); + )(@event); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* LoadBMP([NativeTypeName("const char *")] sbyte* file) => - DllImport.LoadBMP(file); + public static byte PushEvent(Event* @event) => DllImport.PushEvent(@event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.LoadBMP([NativeTypeName("const char *")] Ref file) + MaybeBool ISdl.PushEvent(Ref @event) { - fixed (sbyte* __dsl_file = file) + fixed (Event* __dsl_event = @event) { - return (Surface*)((ISdl)this).LoadBMP(__dsl_file); + return (MaybeBool)(byte)((ISdl)this).PushEvent(__dsl_event); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr LoadBMP([NativeTypeName("const char *")] Ref file) => - DllImport.LoadBMP(file); + public static MaybeBool PushEvent(Ref @event) => DllImport.PushEvent(@event); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => + void ISdl.PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => ( - (delegate* unmanaged)( - _slots[541] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[750] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[541] = nativeContext.LoadFunction("SDL_LoadBMP_IO", "SDL3") + : _slots[750] = nativeContext.LoadFunction( + "SDL_PushGPUComputeUniformData", + "SDL3" + ) ) - )(src, closeio); + )(command_buffer, slot_index, data, length); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* LoadBMPIO(IOStreamHandle src, [NativeTypeName("bool")] byte closeio) => - DllImport.LoadBMPIO(src, closeio); + public static void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUComputeUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.LoadBMPIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => (Surface*)((ISdl)this).LoadBMPIO(src, (byte)closeio); + void ISdl.PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) + { + fixed (void* __dsl_data = data) + { + ((ISdl)this).PushGPUComputeUniformData(command_buffer, slot_index, __dsl_data, length); + } + } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUComputeUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr LoadBMPIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio - ) => DllImport.LoadBMPIO(src, closeio); + public static void PushGPUComputeUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUComputeUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.LoadFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("size_t *")] nuint* datasize + void ISdl.PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name ) => ( - (delegate* unmanaged)( - _slots[542] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[751] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[542] = nativeContext.LoadFunction("SDL_LoadFile", "SDL3") + : _slots[751] = nativeContext.LoadFunction("SDL_PushGPUDebugGroup", "SDL3") ) - )(file, datasize); + )(command_buffer, name); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* LoadFile( - [NativeTypeName("const char *")] sbyte* file, - [NativeTypeName("size_t *")] nuint* datasize - ) => DllImport.LoadFile(file, datasize); + public static void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.PushGPUDebugGroup(command_buffer, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.LoadFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("size_t *")] Ref datasize + void ISdl.PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name ) { - fixed (nuint* __dsl_datasize = datasize) - fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_name = name) { - return (void*)((ISdl)this).LoadFile(__dsl_file, __dsl_datasize); + ((ISdl)this).PushGPUDebugGroup(command_buffer, __dsl_name); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUDebugGroup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr LoadFile( - [NativeTypeName("const char *")] Ref file, - [NativeTypeName("size_t *")] Ref datasize - ) => DllImport.LoadFile(file, datasize); + public static void PushGPUDebugGroup( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("const char *")] Ref name + ) => DllImport.PushGPUDebugGroup(command_buffer, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] nuint* datasize, - [NativeTypeName("bool")] byte closeio + void ISdl.PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length ) => ( - (delegate* unmanaged)( - _slots[543] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[752] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[543] = nativeContext.LoadFunction("SDL_LoadFile_IO", "SDL3") + : _slots[752] = nativeContext.LoadFunction( + "SDL_PushGPUFragmentUniformData", + "SDL3" + ) ) - )(src, datasize, closeio); + )(command_buffer, slot_index, data, length); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] nuint* datasize, - [NativeTypeName("bool")] byte closeio - ) => DllImport.LoadFileIO(src, datasize, closeio); + public static void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUFragmentUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] Ref datasize, - [NativeTypeName("bool")] MaybeBool closeio + void ISdl.PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length ) { - fixed (nuint* __dsl_datasize = datasize) + fixed (void* __dsl_data = data) { - return (void*)((ISdl)this).LoadFileIO(src, __dsl_datasize, (byte)closeio); + ((ISdl)this).PushGPUFragmentUniformData(command_buffer, slot_index, __dsl_data, length); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFile_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUFragmentUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr LoadFileIO( - IOStreamHandle src, - [NativeTypeName("size_t *")] Ref datasize, - [NativeTypeName("bool")] MaybeBool closeio - ) => DllImport.LoadFileIO(src, datasize, closeio); + public static void PushGPUFragmentUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUFragmentUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] sbyte* name + void ISdl.PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length ) => ( - (delegate* unmanaged)( - _slots[544] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[753] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[544] = nativeContext.LoadFunction("SDL_LoadFunction", "SDL3") + : _slots[753] = nativeContext.LoadFunction( + "SDL_PushGPUVertexUniformData", + "SDL3" + ) ) - )(handle, name); + )(command_buffer, slot_index, data, length); - [return: NativeTypeName("SDL_FunctionPointer")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.LoadFunction(handle, name); + public static void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] void* data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUVertexUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - FunctionPointer ISdl.LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] Ref name + void ISdl.PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length ) { - fixed (sbyte* __dsl_name = name) + fixed (void* __dsl_data = data) { - return (FunctionPointer)((ISdl)this).LoadFunction(handle, __dsl_name); + ((ISdl)this).PushGPUVertexUniformData(command_buffer, slot_index, __dsl_data, length); } } - [return: NativeTypeName("SDL_FunctionPointer")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_PushGPUVertexUniformData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static FunctionPointer LoadFunction( - SharedObjectHandle handle, - [NativeTypeName("const char *")] Ref name - ) => DllImport.LoadFunction(handle, name); + public static void PushGPUVertexUniformData( + GPUCommandBufferHandle command_buffer, + [NativeTypeName("Uint32")] uint slot_index, + [NativeTypeName("const void *")] Ref data, + [NativeTypeName("Uint32")] uint length + ) => DllImport.PushGPUVertexUniformData(command_buffer, slot_index, data, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SharedObjectHandle ISdl.LoadObject([NativeTypeName("const char *")] sbyte* sofile) => + byte ISdl.PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] void* buf, + int len + ) => ( - (delegate* unmanaged)( - _slots[545] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[754] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[545] = nativeContext.LoadFunction("SDL_LoadObject", "SDL3") + : _slots[754] = nativeContext.LoadFunction("SDL_PutAudioStreamData", "SDL3") ) - )(sofile); + )(stream, buf, len); - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SharedObjectHandle LoadObject([NativeTypeName("const char *")] sbyte* sofile) => - DllImport.LoadObject(sofile); + public static byte PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] void* buf, + int len + ) => DllImport.PutAudioStreamData(stream, buf, len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SharedObjectHandle ISdl.LoadObject([NativeTypeName("const char *")] Ref sofile) + MaybeBool ISdl.PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] Ref buf, + int len + ) { - fixed (sbyte* __dsl_sofile = sofile) + fixed (void* __dsl_buf = buf) { - return (SharedObjectHandle)((ISdl)this).LoadObject(__dsl_sofile); + return (MaybeBool)(byte)((ISdl)this).PutAudioStreamData(stream, __dsl_buf, len); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadObject")] + [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SharedObjectHandle LoadObject( - [NativeTypeName("const char *")] Ref sofile - ) => DllImport.LoadObject(sofile); + public static MaybeBool PutAudioStreamData( + AudioStreamHandle stream, + [NativeTypeName("const void *")] Ref buf, + int len + ) => DllImport.PutAudioStreamData(stream, buf, len); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LoadWAV( - [NativeTypeName("const char *")] sbyte* path, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len + void ISdl.Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare ) => ( - (delegate* unmanaged)( - _slots[546] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[755] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[546] = nativeContext.LoadFunction("SDL_LoadWAV", "SDL3") + : _slots[755] = nativeContext.LoadFunction("SDL_qsort", "SDL3") ) - )(path, spec, audio_buf, audio_len); + )(@base, nmemb, size, compare); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LoadWAV( - [NativeTypeName("const char *")] sbyte* path, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => DllImport.LoadWAV(path, spec, audio_buf, audio_len); + public static void Qsort( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => DllImport.Qsort(@base, nmemb, size, compare); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LoadWAV( - [NativeTypeName("const char *")] Ref path, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len + void ISdl.Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare ) { - fixed (uint* __dsl_audio_len = audio_len) - fixed (byte** __dsl_audio_buf = audio_buf) - fixed (AudioSpec* __dsl_spec = spec) - fixed (sbyte* __dsl_path = path) + fixed (void* __dsl_base = @base) { - return (MaybeBool) - (byte) - ((ISdl)this).LoadWAV(__dsl_path, __dsl_spec, __dsl_audio_buf, __dsl_audio_len); + ((ISdl)this).Qsort(__dsl_base, nmemb, size, compare); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LoadWAV( - [NativeTypeName("const char *")] Ref path, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) => DllImport.LoadWAV(path, spec, audio_buf, audio_len); + public static void Qsort( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback")] CompareCallback compare + ) => DllImport.Qsort(@base, nmemb, size, compare); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len + void ISdl.QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[547] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[756] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[547] = nativeContext.LoadFunction("SDL_LoadWAV_IO", "SDL3") + : _slots[756] = nativeContext.LoadFunction("SDL_qsort_r", "SDL3") ) - )(src, closeio, spec, audio_buf, audio_len); + )(@base, nmemb, size, compare, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] byte closeio, - AudioSpec* spec, - [NativeTypeName("Uint8 **")] byte** audio_buf, - [NativeTypeName("Uint32 *")] uint* audio_len - ) => DllImport.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); + public static void QsortR( + void* @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + void* userdata + ) => DllImport.QsortR(@base, nmemb, size, compare, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len + void ISdl.QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata ) { - fixed (uint* __dsl_audio_len = audio_len) - fixed (byte** __dsl_audio_buf = audio_buf) - fixed (AudioSpec* __dsl_spec = spec) + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_base = @base) { - return (MaybeBool) - (byte) - ((ISdl)this).LoadWAVIO( - src, - (byte)closeio, - __dsl_spec, - __dsl_audio_buf, - __dsl_audio_len - ); + ((ISdl)this).QsortR(__dsl_base, nmemb, size, compare, __dsl_userdata); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LoadWAV_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_qsort_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LoadWAVIO( - IOStreamHandle src, - [NativeTypeName("bool")] MaybeBool closeio, - Ref spec, - [NativeTypeName("Uint8 **")] Ref2D audio_buf, - [NativeTypeName("Uint32 *")] Ref audio_len - ) => DllImport.LoadWAVIO(src, closeio, spec, audio_buf, audio_len); + public static void QsortR( + Ref @base, + [NativeTypeName("size_t")] nuint nmemb, + [NativeTypeName("size_t")] nuint size, + [NativeTypeName("SDL_CompareCallback_r")] CompareCallbackR compare, + Ref userdata + ) => DllImport.QsortR(@base, nmemb, size, compare, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LockAudioStream(AudioStreamHandle stream) => - (MaybeBool)(byte)((ISdl)this).LockAudioStreamRaw(stream); + MaybeBool ISdl.QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + (MaybeBool)(byte)((ISdl)this).QueryGPUFenceRaw(device, fence); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LockAudioStream(AudioStreamHandle stream) => - DllImport.LockAudioStream(stream); + public static MaybeBool QueryGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + DllImport.QueryGPUFence(device, fence); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LockAudioStreamRaw(AudioStreamHandle stream) => + byte ISdl.QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence) => ( - (delegate* unmanaged)( - _slots[548] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[757] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[548] = nativeContext.LoadFunction("SDL_LockAudioStream", "SDL3") + : _slots[757] = nativeContext.LoadFunction("SDL_QueryGPUFence", "SDL3") ) - )(stream); + )(device, fence); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockAudioStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_QueryGPUFence")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LockAudioStreamRaw(AudioStreamHandle stream) => - DllImport.LockAudioStreamRaw(stream); + public static byte QueryGPUFenceRaw(GPUDeviceHandle device, GPUFenceHandle fence) => + DllImport.QueryGPUFenceRaw(device, fence); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockJoysticks() => + void ISdl.Quit() => ( (delegate* unmanaged)( - _slots[549] is not null and var loadedFnPtr + _slots[758] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[549] = nativeContext.LoadFunction("SDL_LockJoysticks", "SDL3") + : _slots[758] = nativeContext.LoadFunction("SDL_Quit", "SDL3") ) )(); - [NativeFunction("SDL3", EntryPoint = "SDL_LockJoysticks")] + [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockJoysticks() => DllImport.LockJoysticks(); + public static void Quit() => DllImport.Quit(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockMutex(MutexHandle mutex) => + void ISdl.QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => ( - (delegate* unmanaged)( - _slots[550] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[759] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[550] = nativeContext.LoadFunction("SDL_LockMutex", "SDL3") + : _slots[759] = nativeContext.LoadFunction("SDL_QuitSubSystem", "SDL3") ) - )(mutex); + )(flags); - [NativeFunction("SDL3", EntryPoint = "SDL_LockMutex")] + [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockMutex(MutexHandle mutex) => DllImport.LockMutex(mutex); + public static void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + DllImport.QuitSubSystem(flags); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - (MaybeBool)(byte)((ISdl)this).LockPropertiesRaw(props); + MaybeBool ISdl.RaiseWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).RaiseWindowRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => - DllImport.LockProperties(props); + public static MaybeBool RaiseWindow(WindowHandle window) => DllImport.RaiseWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => + byte ISdl.RaiseWindowRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[551] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[760] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[551] = nativeContext.LoadFunction("SDL_LockProperties", "SDL3") + : _slots[760] = nativeContext.LoadFunction("SDL_RaiseWindow", "SDL3") ) - )(props); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockProperties")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LockPropertiesRaw([NativeTypeName("SDL_PropertiesID")] uint props) => - DllImport.LockPropertiesRaw(props); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockRWLockForReading(RWLockHandle rwlock) => - ( - (delegate* unmanaged)( - _slots[552] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[552] = nativeContext.LoadFunction("SDL_LockRWLockForReading", "SDL3") - ) - )(rwlock); - - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForReading")] + [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockRWLockForReading(RWLockHandle rwlock) => - DllImport.LockRWLockForReading(rwlock); + public static byte RaiseWindowRaw(WindowHandle window) => DllImport.RaiseWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockRWLockForWriting(RWLockHandle rwlock) => + int ISdl.Rand([NativeTypeName("Sint32")] int n) => ( - (delegate* unmanaged)( - _slots[553] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[761] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[553] = nativeContext.LoadFunction("SDL_LockRWLockForWriting", "SDL3") + : _slots[761] = nativeContext.LoadFunction("SDL_rand", "SDL3") ) - )(rwlock); + )(n); - [NativeFunction("SDL3", EntryPoint = "SDL_LockRWLockForWriting")] + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockRWLockForWriting(RWLockHandle rwlock) => - DllImport.LockRWLockForWriting(rwlock); + public static int Rand([NativeTypeName("Sint32")] int n) => DllImport.Rand(n); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => + uint ISdl.RandBits() => ( - (delegate* unmanaged)( - _slots[554] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[762] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[554] = nativeContext.LoadFunction("SDL_LockSpinlock", "SDL3") + : _slots[762] = nativeContext.LoadFunction("SDL_rand_bits", "SDL3") ) - )(@lock); - - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => - DllImport.LockSpinlock(@lock); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) - { - fixed (int* __dsl_lock = @lock) - { - ((ISdl)this).LockSpinlock(__dsl_lock); - } - } + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSpinlock")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @lock) => - DllImport.LockSpinlock(@lock); + public static uint RandBits() => DllImport.RandBits(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LockSurface(Surface* surface) => + uint ISdl.RandBitsR([NativeTypeName("Uint64 *")] ulong* state) => ( - (delegate* unmanaged)( - _slots[555] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[763] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[555] = nativeContext.LoadFunction("SDL_LockSurface", "SDL3") + : _slots[763] = nativeContext.LoadFunction("SDL_rand_bits_r", "SDL3") ) - )(surface); + )(state); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LockSurface(Surface* surface) => DllImport.LockSurface(surface); + public static uint RandBitsR([NativeTypeName("Uint64 *")] ulong* state) => + DllImport.RandBitsR(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LockSurface(Ref surface) + uint ISdl.RandBitsR([NativeTypeName("Uint64 *")] Ref state) { - fixed (Surface* __dsl_surface = surface) + fixed (ulong* __dsl_state = state) { - return (MaybeBool)(byte)((ISdl)this).LockSurface(__dsl_surface); + return (uint)((ISdl)this).RandBitsR(__dsl_state); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_bits_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LockSurface(Ref surface) => - DllImport.LockSurface(surface); + public static uint RandBitsR([NativeTypeName("Uint64 *")] Ref state) => + DllImport.RandBitsR(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LockTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - void** pixels, - int* pitch - ) => + int ISdl.RandR([NativeTypeName("Uint64 *")] ulong* state, [NativeTypeName("Sint32")] int n) => ( - (delegate* unmanaged)( - _slots[556] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[764] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[556] = nativeContext.LoadFunction("SDL_LockTexture", "SDL3") + : _slots[764] = nativeContext.LoadFunction("SDL_rand_r", "SDL3") ) - )(texture, rect, pixels, pitch); + )(state, n); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [return: NativeTypeName("Sint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LockTexture( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - void** pixels, - int* pitch - ) => DllImport.LockTexture(texture, rect, pixels, pitch); + public static int RandR( + [NativeTypeName("Uint64 *")] ulong* state, + [NativeTypeName("Sint32")] int n + ) => DllImport.RandR(state, n); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LockTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D pixels, - Ref pitch - ) + int ISdl.RandR([NativeTypeName("Uint64 *")] Ref state, [NativeTypeName("Sint32")] int n) { - fixed (int* __dsl_pitch = pitch) - fixed (void** __dsl_pixels = pixels) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) + fixed (ulong* __dsl_state = state) { - return (MaybeBool) - (byte) - ((ISdl)this).LockTexture(__dsl_texture, __dsl_rect, __dsl_pixels, __dsl_pitch); + return (int)((ISdl)this).RandR(__dsl_state, n); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("Sint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_rand_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LockTexture( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D pixels, - Ref pitch - ) => DllImport.LockTexture(texture, rect, pixels, pitch); + public static int RandR( + [NativeTypeName("Uint64 *")] Ref state, + [NativeTypeName("Sint32")] int n + ) => DllImport.RandR(state, n); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.LockTextureToSurface( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - Surface** surface - ) => + float ISdl.Randf() => ( - (delegate* unmanaged)( - _slots[557] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[765] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[557] = nativeContext.LoadFunction("SDL_LockTextureToSurface", "SDL3") + : _slots[765] = nativeContext.LoadFunction("SDL_randf", "SDL3") ) - )(texture, rect, surface); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte LockTextureToSurface( - Texture* texture, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - Surface** surface - ) => DllImport.LockTextureToSurface(texture, rect, surface); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.LockTextureToSurface( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D surface - ) - { - fixed (Surface** __dsl_surface = surface) - fixed (Rect* __dsl_rect = rect) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte)((ISdl)this).LockTextureToSurface(__dsl_texture, __dsl_rect, __dsl_surface); - } - } + )(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LockTextureToSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_randf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool LockTextureToSurface( - Ref texture, - [NativeTypeName("const SDL_Rect *")] Ref rect, - Ref2D surface - ) => DllImport.LockTextureToSurface(texture, rect, surface); + public static float Randf() => DllImport.Randf(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => + float ISdl.RandfR([NativeTypeName("Uint64 *")] ulong* state) => ( - (delegate* unmanaged)( - _slots[558] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[766] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[558] = nativeContext.LoadFunction("SDL_LogMessageV", "SDL3") + : _slots[766] = nativeContext.LoadFunction("SDL_randf_r", "SDL3") ) - )(category, priority, fmt, ap); - - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => DllImport.LogMessageV(category, priority, fmt, ap); + )(state); + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) + public static float RandfR([NativeTypeName("Uint64 *")] ulong* state) => + DllImport.RandfR(state); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.RandfR([NativeTypeName("Uint64 *")] Ref state) { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) + fixed (ulong* __dsl_state = state) { - ((ISdl)this).LogMessageV(category, priority, __dsl_fmt, __dsl_ap); + return (float)((ISdl)this).RandfR(__dsl_state); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_LogMessageV")] + [NativeFunction("SDL3", EntryPoint = "SDL_randf_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void LogMessageV( - int category, - LogPriority priority, - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => DllImport.LogMessageV(category, priority, fmt, ap); + public static float RandfR([NativeTypeName("Uint64 *")] Ref state) => + DllImport.RandfR(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => + nuint ISdl.ReadIO(IOStreamHandle context, void* ptr, [NativeTypeName("size_t")] nuint size) => ( - (delegate* unmanaged)( - _slots[559] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[767] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[559] = nativeContext.LoadFunction("SDL_MapRGB", "SDL3") + : _slots[767] = nativeContext.LoadFunction("SDL_ReadIO", "SDL3") ) - )(format, palette, r, g, b); + )(context, ptr, size); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.MapRGB(format, palette, r, g, b); + public static nuint ReadIO( + IOStreamHandle context, + void* ptr, + [NativeTypeName("size_t")] nuint size + ) => DllImport.ReadIO(context, ptr, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) + nuint ISdl.ReadIO(IOStreamHandle context, Ref ptr, [NativeTypeName("size_t")] nuint size) { - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) + fixed (void* __dsl_ptr = ptr) { - return (uint)((ISdl)this).MapRGB(__dsl_format, __dsl_palette, r, g, b); + return (nuint)((ISdl)this).ReadIO(context, __dsl_ptr, size); } } - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapRGB( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.MapRGB(format, palette, r, g, b); + public static nuint ReadIO( + IOStreamHandle context, + Ref ptr, + [NativeTypeName("size_t")] nuint size + ) => DllImport.ReadIO(context, ptr, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + void* ISdl.ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode ) => ( - (delegate* unmanaged)( - _slots[560] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[768] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[560] = nativeContext.LoadFunction("SDL_MapRGBA", "SDL3") + : _slots[768] = nativeContext.LoadFunction("SDL_ReadProcess", "SDL3") ) - )(format, palette, r, g, b, a); + )(process, datasize, exitcode); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] PixelFormatDetails* format, - [NativeTypeName("const SDL_Palette *")] Palette* palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.MapRgba(format, palette, r, g, b, a); + public static void* ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] nuint* datasize, + int* exitcode + ) => DllImport.ReadProcess(process, datasize, exitcode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + Ptr ISdl.ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode ) { - fixed (Palette* __dsl_palette = palette) - fixed (PixelFormatDetails* __dsl_format = format) + fixed (int* __dsl_exitcode = exitcode) + fixed (nuint* __dsl_datasize = datasize) { - return (uint)((ISdl)this).MapRgba(__dsl_format, __dsl_palette, r, g, b, a); + return (void*)((ISdl)this).ReadProcess(process, __dsl_datasize, __dsl_exitcode); } } - [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadProcess")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapRgba( - [NativeTypeName("const SDL_PixelFormatDetails *")] Ref format, - [NativeTypeName("const SDL_Palette *")] Ref palette, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.MapRgba(format, palette, r, g, b, a); + public static Ptr ReadProcess( + ProcessHandle process, + [NativeTypeName("size_t *")] Ref datasize, + Ref exitcode + ) => DllImport.ReadProcess(process, datasize, exitcode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapSurfaceRGB( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => + byte ISdl.ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => ( - (delegate* unmanaged)( - _slots[561] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[769] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[561] = nativeContext.LoadFunction("SDL_MapSurfaceRGB", "SDL3") + : _slots[769] = nativeContext.LoadFunction("SDL_ReadS16BE", "SDL3") ) - )(surface, r, g, b); + )(src, value); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapSurfaceRGB( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.MapSurfaceRGB(surface, r, g, b); + public static byte ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + DllImport.ReadS16BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapSurfaceRGB( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b + MaybeBool ISdl.ReadS16BE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value ) { - fixed (Surface* __dsl_surface = surface) + fixed (short* __dsl_value = value) { - return (uint)((ISdl)this).MapSurfaceRGB(__dsl_surface, r, g, b); + return (MaybeBool)(byte)((ISdl)this).ReadS16BE(src, __dsl_value); } } - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGB")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapSurfaceRGB( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.MapSurfaceRGB(surface, r, g, b); + public static MaybeBool ReadS16BE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) => DllImport.ReadS16BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapSurfaceRgba( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => + byte ISdl.ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => ( - (delegate* unmanaged)( - _slots[562] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[770] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[562] = nativeContext.LoadFunction("SDL_MapSurfaceRGBA", "SDL3") + : _slots[770] = nativeContext.LoadFunction("SDL_ReadS16LE", "SDL3") ) - )(surface, r, g, b, a); + )(src, value); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapSurfaceRgba( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.MapSurfaceRgba(surface, r, g, b, a); + public static byte ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + DllImport.ReadS16LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.MapSurfaceRgba( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a + MaybeBool ISdl.ReadS16LE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value ) { - fixed (Surface* __dsl_surface = surface) + fixed (short* __dsl_value = value) { - return (uint)((ISdl)this).MapSurfaceRgba(__dsl_surface, r, g, b, a); + return (MaybeBool)(byte)((ISdl)this).ReadS16LE(src, __dsl_value); } } - [return: NativeTypeName("Uint32")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MapSurfaceRGBA")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint MapSurfaceRgba( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.MapSurfaceRgba(surface, r, g, b, a); + public static MaybeBool ReadS16LE( + IOStreamHandle src, + [NativeTypeName("Sint16 *")] Ref value + ) => DllImport.ReadS16LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.MaximizeWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).MaximizeWindowRaw(window); + byte ISdl.ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + ( + (delegate* unmanaged)( + _slots[771] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[771] = nativeContext.LoadFunction("SDL_ReadS32BE", "SDL3") + ) + )(src, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + DllImport.ReadS32BE(src, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] Ref value) + { + fixed (int* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadS32BE(src, __dsl_value); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool MaximizeWindow(WindowHandle window) => - DllImport.MaximizeWindow(window); + public static MaybeBool ReadS32BE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) => DllImport.ReadS32BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.MaximizeWindowRaw(WindowHandle window) => + byte ISdl.ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => ( - (delegate* unmanaged)( - _slots[563] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[772] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[563] = nativeContext.LoadFunction("SDL_MaximizeWindow", "SDL3") + : _slots[772] = nativeContext.LoadFunction("SDL_ReadS32LE", "SDL3") ) - )(window); + )(src, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MaximizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte MaximizeWindowRaw(WindowHandle window) => - DllImport.MaximizeWindowRaw(window); + public static byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + DllImport.ReadS32LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.MemoryBarrierAcquireFunction() => - ( - (delegate* unmanaged)( - _slots[564] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[564] = nativeContext.LoadFunction( - "SDL_MemoryBarrierAcquireFunction", - "SDL3" - ) - ) - )(); + MaybeBool ISdl.ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] Ref value) + { + fixed (int* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadS32LE(src, __dsl_value); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierAcquireFunction")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void MemoryBarrierAcquireFunction() => DllImport.MemoryBarrierAcquireFunction(); + public static MaybeBool ReadS32LE( + IOStreamHandle src, + [NativeTypeName("Sint32 *")] Ref value + ) => DllImport.ReadS32LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.MemoryBarrierReleaseFunction() => + byte ISdl.ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => ( - (delegate* unmanaged)( - _slots[565] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[773] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[565] = nativeContext.LoadFunction( - "SDL_MemoryBarrierReleaseFunction", - "SDL3" - ) + : _slots[773] = nativeContext.LoadFunction("SDL_ReadS64BE", "SDL3") ) - )(); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_MemoryBarrierReleaseFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void MemoryBarrierReleaseFunction() => DllImport.MemoryBarrierReleaseFunction(); + public static byte ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => + DllImport.ReadS64BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.MetalCreateView(WindowHandle window) => (void*)((ISdl)this).MetalCreateViewRaw(window); + MaybeBool ISdl.ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] Ref value) + { + fixed (long* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadS64BE(src, __dsl_value); + } + } - [return: NativeTypeName("SDL_MetalView")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr MetalCreateView(WindowHandle window) => DllImport.MetalCreateView(window); + public static MaybeBool ReadS64BE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) => DllImport.ReadS64BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.MetalCreateViewRaw(WindowHandle window) => + byte ISdl.ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => ( - (delegate* unmanaged)( - _slots[566] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[774] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[566] = nativeContext.LoadFunction("SDL_Metal_CreateView", "SDL3") + : _slots[774] = nativeContext.LoadFunction("SDL_ReadS64LE", "SDL3") ) - )(window); + )(src, value); - [return: NativeTypeName("SDL_MetalView")] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_CreateView")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* MetalCreateViewRaw(WindowHandle window) => - DllImport.MetalCreateViewRaw(window); + public static byte ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => + DllImport.ReadS64LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => + MaybeBool ISdl.ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] Ref value) + { + fixed (long* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadS64LE(src, __dsl_value); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ReadS64LE( + IOStreamHandle src, + [NativeTypeName("Sint64 *")] Ref value + ) => DllImport.ReadS64LE(src, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => ( - (delegate* unmanaged)( - _slots[567] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[775] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[567] = nativeContext.LoadFunction("SDL_Metal_DestroyView", "SDL3") + : _slots[775] = nativeContext.LoadFunction("SDL_ReadS8", "SDL3") ) - )(view); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] void* view) => - DllImport.MetalDestroyView(view); + public static byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => + DllImport.ReadS8(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) + MaybeBool ISdl.ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] Ref value) { - fixed (void* __dsl_view = view) + fixed (sbyte* __dsl_value = value) { - ((ISdl)this).MetalDestroyView(__dsl_view); + return (MaybeBool)(byte)((ISdl)this).ReadS8(src, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_DestroyView")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void MetalDestroyView([NativeTypeName("SDL_MetalView")] Ref view) => - DllImport.MetalDestroyView(view); + public static MaybeBool ReadS8( + IOStreamHandle src, + [NativeTypeName("Sint8 *")] Ref value + ) => DllImport.ReadS8(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => + byte ISdl.ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + void* destination, + [NativeTypeName("Uint64")] ulong length + ) => ( - (delegate* unmanaged)( - _slots[568] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[776] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[568] = nativeContext.LoadFunction("SDL_Metal_GetLayer", "SDL3") + : _slots[776] = nativeContext.LoadFunction("SDL_ReadStorageFile", "SDL3") ) - )(view); + )(storage, path, destination, length); - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* MetalGetLayer([NativeTypeName("SDL_MetalView")] void* view) => - DllImport.MetalGetLayer(view); + public static byte ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path, + void* destination, + [NativeTypeName("Uint64")] ulong length + ) => DllImport.ReadStorageFile(storage, path, destination, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) + MaybeBool ISdl.ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref destination, + [NativeTypeName("Uint64")] ulong length + ) { - fixed (void* __dsl_view = view) + fixed (void* __dsl_destination = destination) + fixed (sbyte* __dsl_path = path) { - return (void*)((ISdl)this).MetalGetLayer(__dsl_view); + return (MaybeBool) + (byte)((ISdl)this).ReadStorageFile(storage, __dsl_path, __dsl_destination, length); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_Metal_GetLayer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr MetalGetLayer([NativeTypeName("SDL_MetalView")] Ref view) => - DllImport.MetalGetLayer(view); + public static MaybeBool ReadStorageFile( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path, + Ref destination, + [NativeTypeName("Uint64")] ulong length + ) => DllImport.ReadStorageFile(storage, path, destination, length); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.MinimizeWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).MinimizeWindowRaw(window); + byte ISdl.ReadSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => + ( + (delegate* unmanaged)( + _slots[777] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[777] = nativeContext.LoadFunction("SDL_ReadSurfacePixel", "SDL3") + ) + )(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool MinimizeWindow(WindowHandle window) => - DllImport.MinimizeWindow(window); + public static byte ReadSurfacePixel( + Surface* surface, + int x, + int y, + [NativeTypeName("Uint8 *")] byte* r, + [NativeTypeName("Uint8 *")] byte* g, + [NativeTypeName("Uint8 *")] byte* b, + [NativeTypeName("Uint8 *")] byte* a + ) => DllImport.ReadSurfacePixel(surface, x, y, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.MinimizeWindowRaw(WindowHandle window) => - ( - (delegate* unmanaged)( - _slots[569] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[569] = nativeContext.LoadFunction("SDL_MinimizeWindow", "SDL3") - ) - )(window); + MaybeBool ISdl.ReadSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) + { + fixed (byte* __dsl_a = a) + fixed (byte* __dsl_b = b) + fixed (byte* __dsl_g = g) + fixed (byte* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte) + ((ISdl)this).ReadSurfacePixel( + __dsl_surface, + x, + y, + __dsl_r, + __dsl_g, + __dsl_b, + __dsl_a + ); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MinimizeWindow")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte MinimizeWindowRaw(WindowHandle window) => - DllImport.MinimizeWindowRaw(window); + public static MaybeBool ReadSurfacePixel( + Ref surface, + int x, + int y, + [NativeTypeName("Uint8 *")] Ref r, + [NativeTypeName("Uint8 *")] Ref g, + [NativeTypeName("Uint8 *")] Ref b, + [NativeTypeName("Uint8 *")] Ref a + ) => DllImport.ReadSurfacePixel(surface, x, y, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.MixAudio( - [NativeTypeName("Uint8 *")] byte* dst, - [NativeTypeName("const Uint8 *")] byte* src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume + byte ISdl.ReadSurfacePixelFloat( + Surface* surface, + int x, + int y, + float* r, + float* g, + float* b, + float* a ) => ( - (delegate* unmanaged)( - _slots[570] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[778] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[570] = nativeContext.LoadFunction("SDL_MixAudio", "SDL3") + : _slots[778] = nativeContext.LoadFunction("SDL_ReadSurfacePixelFloat", "SDL3") ) - )(dst, src, format, len, volume); + )(surface, x, y, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte MixAudio( - [NativeTypeName("Uint8 *")] byte* dst, - [NativeTypeName("const Uint8 *")] byte* src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume - ) => DllImport.MixAudio(dst, src, format, len, volume); + public static byte ReadSurfacePixelFloat( + Surface* surface, + int x, + int y, + float* r, + float* g, + float* b, + float* a + ) => DllImport.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.MixAudio( - [NativeTypeName("Uint8 *")] Ref dst, - [NativeTypeName("const Uint8 *")] Ref src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume + MaybeBool ISdl.ReadSurfacePixelFloat( + Ref surface, + int x, + int y, + Ref r, + Ref g, + Ref b, + Ref a ) { - fixed (byte* __dsl_src = src) - fixed (byte* __dsl_dst = dst) + fixed (float* __dsl_a = a) + fixed (float* __dsl_b = b) + fixed (float* __dsl_g = g) + fixed (float* __dsl_r = r) + fixed (Surface* __dsl_surface = surface) { return (MaybeBool) - (byte)((ISdl)this).MixAudio(__dsl_dst, __dsl_src, format, len, volume); + (byte) + ((ISdl)this).ReadSurfacePixelFloat( + __dsl_surface, + x, + y, + __dsl_r, + __dsl_g, + __dsl_b, + __dsl_a + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_MixAudio")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool MixAudio( - [NativeTypeName("Uint8 *")] Ref dst, - [NativeTypeName("const Uint8 *")] Ref src, - AudioFormat format, - [NativeTypeName("Uint32")] uint len, - float volume - ) => DllImport.MixAudio(dst, src, format, len, volume); + public static MaybeBool ReadSurfacePixelFloat( + Ref surface, + int x, + int y, + Ref r, + Ref g, + Ref b, + Ref a + ) => DllImport.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationDidEnterBackground() => + byte ISdl.ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => ( - (delegate* unmanaged)( - _slots[571] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[779] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[571] = nativeContext.LoadFunction( - "SDL_OnApplicationDidEnterBackground", - "SDL3" - ) + : _slots[779] = nativeContext.LoadFunction("SDL_ReadU16BE", "SDL3") ) - )(); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterBackground")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationDidEnterBackground() => - DllImport.OnApplicationDidEnterBackground(); + public static byte ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => + DllImport.ReadU16BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationDidEnterForeground() => - ( - (delegate* unmanaged)( - _slots[572] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[572] = nativeContext.LoadFunction( - "SDL_OnApplicationDidEnterForeground", - "SDL3" - ) - ) - )(); + MaybeBool ISdl.ReadU16BE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) + { + fixed (ushort* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadU16BE(src, __dsl_value); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidEnterForeground")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationDidEnterForeground() => - DllImport.OnApplicationDidEnterForeground(); + public static MaybeBool ReadU16BE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) => DllImport.ReadU16BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationDidReceiveMemoryWarning() => + byte ISdl.ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => ( - (delegate* unmanaged)( - _slots[573] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[780] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[573] = nativeContext.LoadFunction( - "SDL_OnApplicationDidReceiveMemoryWarning", - "SDL3" - ) + : _slots[780] = nativeContext.LoadFunction("SDL_ReadU16LE", "SDL3") ) - )(); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationDidReceiveMemoryWarning")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationDidReceiveMemoryWarning() => - DllImport.OnApplicationDidReceiveMemoryWarning(); + public static byte ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => + DllImport.ReadU16LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationWillEnterBackground() => - ( - (delegate* unmanaged)( - _slots[574] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[574] = nativeContext.LoadFunction( - "SDL_OnApplicationWillEnterBackground", - "SDL3" - ) - ) - )(); + MaybeBool ISdl.ReadU16LE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) + { + fixed (ushort* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadU16LE(src, __dsl_value); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterBackground")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationWillEnterBackground() => - DllImport.OnApplicationWillEnterBackground(); + public static MaybeBool ReadU16LE( + IOStreamHandle src, + [NativeTypeName("Uint16 *")] Ref value + ) => DllImport.ReadU16LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationWillEnterForeground() => + byte ISdl.ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => ( - (delegate* unmanaged)( - _slots[575] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[781] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[575] = nativeContext.LoadFunction( - "SDL_OnApplicationWillEnterForeground", - "SDL3" - ) + : _slots[781] = nativeContext.LoadFunction("SDL_ReadU32BE", "SDL3") ) - )(); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillEnterForeground")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationWillEnterForeground() => - DllImport.OnApplicationWillEnterForeground(); + public static byte ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + DllImport.ReadU32BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.OnApplicationWillTerminate() => - ( - (delegate* unmanaged)( - _slots[576] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[576] = nativeContext.LoadFunction( - "SDL_OnApplicationWillTerminate", - "SDL3" - ) - ) - )(); + MaybeBool ISdl.ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] Ref value) + { + fixed (uint* __dsl_value = value) + { + return (MaybeBool)(byte)((ISdl)this).ReadU32BE(src, __dsl_value); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_OnApplicationWillTerminate")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void OnApplicationWillTerminate() => DllImport.OnApplicationWillTerminate(); + public static MaybeBool ReadU32BE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) => DllImport.ReadU32BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec - ) => + byte ISdl.ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => ( - (delegate* unmanaged)( - _slots[577] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[782] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[577] = nativeContext.LoadFunction("SDL_OpenAudioDevice", "SDL3") + : _slots[782] = nativeContext.LoadFunction("SDL_ReadU32LE", "SDL3") ) - )(devid, spec); + )(src, value); - [return: NativeTypeName("SDL_AudioDeviceID")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec - ) => DllImport.OpenAudioDevice(devid, spec); + public static byte ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + DllImport.ReadU32LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec - ) + MaybeBool ISdl.ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] Ref value) { - fixed (AudioSpec* __dsl_spec = spec) + fixed (uint* __dsl_value = value) { - return (uint)((ISdl)this).OpenAudioDevice(devid, __dsl_spec); + return (MaybeBool)(byte)((ISdl)this).ReadU32LE(src, __dsl_value); } } - [return: NativeTypeName("SDL_AudioDeviceID")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint OpenAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec - ) => DllImport.OpenAudioDevice(devid, spec); + public static MaybeBool ReadU32LE( + IOStreamHandle src, + [NativeTypeName("Uint32 *")] Ref value + ) => DllImport.ReadU32LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AudioStreamHandle ISdl.OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => + byte ISdl.ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => ( - (delegate* unmanaged)( - _slots[578] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[783] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[578] = nativeContext.LoadFunction("SDL_OpenAudioDeviceStream", "SDL3") + : _slots[783] = nativeContext.LoadFunction("SDL_ReadU64BE", "SDL3") ) - )(devid, spec, callback, userdata); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => DllImport.OpenAudioDeviceStream(devid, spec, callback, userdata); + public static byte ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + DllImport.ReadU64BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AudioStreamHandle ISdl.OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata + MaybeBool ISdl.ReadU64BE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value ) { - fixed (void* __dsl_userdata = userdata) - fixed (AudioSpec* __dsl_spec = spec) + fixed (ulong* __dsl_value = value) { - return (AudioStreamHandle) - ((ISdl)this).OpenAudioDeviceStream(devid, __dsl_spec, callback, __dsl_userdata); + return (MaybeBool)(byte)((ISdl)this).ReadU64BE(src, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenAudioDeviceStream")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AudioStreamHandle OpenAudioDeviceStream( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("const SDL_AudioSpec *")] Ref spec, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) => DllImport.OpenAudioDeviceStream(devid, spec, callback, userdata); + public static MaybeBool ReadU64BE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) => DllImport.ReadU64BE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CameraHandle ISdl.OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec - ) => + byte ISdl.ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => ( - (delegate* unmanaged)( - _slots[579] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[784] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[579] = nativeContext.LoadFunction("SDL_OpenCamera", "SDL3") + : _slots[784] = nativeContext.LoadFunction("SDL_ReadU64LE", "SDL3") ) - )(instance_id, spec); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] CameraSpec* spec - ) => DllImport.OpenCamera(instance_id, spec); + public static byte ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + DllImport.ReadU64LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - CameraHandle ISdl.OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] Ref spec + MaybeBool ISdl.ReadU64LE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value ) { - fixed (CameraSpec* __dsl_spec = spec) + fixed (ulong* __dsl_value = value) { - return (CameraHandle)((ISdl)this).OpenCamera(instance_id, __dsl_spec); + return (MaybeBool)(byte)((ISdl)this).ReadU64LE(src, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenCamera")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static CameraHandle OpenCamera( - [NativeTypeName("SDL_CameraID")] uint instance_id, - [NativeTypeName("const SDL_CameraSpec *")] Ref spec - ) => DllImport.OpenCamera(instance_id, spec); + public static MaybeBool ReadU64LE( + IOStreamHandle src, + [NativeTypeName("Uint64 *")] Ref value + ) => DllImport.ReadU64LE(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => + byte ISdl.ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => ( - (delegate* unmanaged)( - _slots[580] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[785] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[580] = nativeContext.LoadFunction("SDL_OpenFileStorage", "SDL3") + : _slots[785] = nativeContext.LoadFunction("SDL_ReadU8", "SDL3") ) - )(path); + )(src, value); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] sbyte* path) => - DllImport.OpenFileStorage(path); + public static byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => + DllImport.ReadU8(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenFileStorage([NativeTypeName("const char *")] Ref path) + MaybeBool ISdl.ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] Ref value) { - fixed (sbyte* __dsl_path = path) + fixed (byte* __dsl_value = value) { - return (StorageHandle)((ISdl)this).OpenFileStorage(__dsl_path); + return (MaybeBool)(byte)((ISdl)this).ReadU8(src, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenFileStorage")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenFileStorage([NativeTypeName("const char *")] Ref path) => - DllImport.OpenFileStorage(path); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - GamepadHandle ISdl.OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[581] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[581] = nativeContext.LoadFunction("SDL_OpenGamepad", "SDL3") - ) - )(instance_id); - - [NativeFunction("SDL3", EntryPoint = "SDL_OpenGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static GamepadHandle OpenGamepad([NativeTypeName("SDL_JoystickID")] uint instance_id) => - DllImport.OpenGamepad(instance_id); + public static MaybeBool ReadU8( + IOStreamHandle src, + [NativeTypeName("Uint8 *")] Ref value + ) => DllImport.ReadU8(src, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HapticHandle ISdl.OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => + void* ISdl.Realloc(void* mem, [NativeTypeName("size_t")] nuint size) => ( - (delegate* unmanaged)( - _slots[582] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[786] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[582] = nativeContext.LoadFunction("SDL_OpenHaptic", "SDL3") + : _slots[786] = nativeContext.LoadFunction("SDL_realloc", "SDL3") ) - )(instance_id); + )(mem, size); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HapticHandle OpenHaptic([NativeTypeName("SDL_HapticID")] uint instance_id) => - DllImport.OpenHaptic(instance_id); + public static void* Realloc(void* mem, [NativeTypeName("size_t")] nuint size) => + DllImport.Realloc(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HapticHandle ISdl.OpenHapticFromJoystick(JoystickHandle joystick) => - ( - (delegate* unmanaged)( - _slots[583] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[583] = nativeContext.LoadFunction("SDL_OpenHapticFromJoystick", "SDL3") - ) - )(joystick); + Ptr ISdl.Realloc(Ref mem, [NativeTypeName("size_t")] nuint size) + { + fixed (void* __dsl_mem = mem) + { + return (void*)((ISdl)this).Realloc(__dsl_mem, size); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromJoystick")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_realloc")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HapticHandle OpenHapticFromJoystick(JoystickHandle joystick) => - DllImport.OpenHapticFromJoystick(joystick); + public static Ptr Realloc(Ref mem, [NativeTypeName("size_t")] nuint size) => + DllImport.Realloc(mem, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - HapticHandle ISdl.OpenHapticFromMouse() => + uint ISdl.RegisterEvents(int numevents) => ( - (delegate* unmanaged)( - _slots[584] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[787] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[584] = nativeContext.LoadFunction("SDL_OpenHapticFromMouse", "SDL3") + : _slots[787] = nativeContext.LoadFunction("SDL_RegisterEvents", "SDL3") ) - )(); + )(numevents); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenHapticFromMouse")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static HapticHandle OpenHapticFromMouse() => DllImport.OpenHapticFromMouse(); + public static uint RegisterEvents(int numevents) => DllImport.RegisterEvents(numevents); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, - void* userdata - ) => + void ISdl.ReleaseCameraFrame(CameraHandle camera, Surface* frame) => ( - (delegate* unmanaged)( - _slots[585] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[788] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[585] = nativeContext.LoadFunction("SDL_OpenIO", "SDL3") + : _slots[788] = nativeContext.LoadFunction("SDL_ReleaseCameraFrame", "SDL3") ) - )(iface, userdata); + )(camera, frame); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] IOStreamInterface* iface, - void* userdata - ) => DllImport.OpenIO(iface, userdata); + public static void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => + DllImport.ReleaseCameraFrame(camera, frame); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - IOStreamHandle ISdl.OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, - Ref userdata - ) + void ISdl.ReleaseCameraFrame(CameraHandle camera, Ref frame) { - fixed (void* __dsl_userdata = userdata) - fixed (IOStreamInterface* __dsl_iface = iface) - { - return (IOStreamHandle)((ISdl)this).OpenIO(__dsl_iface, __dsl_userdata); - } - } - - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenIO")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static IOStreamHandle OpenIO( - [NativeTypeName("const SDL_IOStreamInterface *")] Ref iface, - Ref userdata - ) => DllImport.OpenIO(iface, userdata); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - JoystickHandle ISdl.OpenJoystick([NativeTypeName("SDL_JoystickID")] uint instance_id) => - ( - (delegate* unmanaged)( - _slots[586] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[586] = nativeContext.LoadFunction("SDL_OpenJoystick", "SDL3") - ) - )(instance_id); + fixed (Surface* __dsl_frame = frame) + { + ((ISdl)this).ReleaseCameraFrame(camera, __dsl_frame); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_OpenJoystick")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static JoystickHandle OpenJoystick( - [NativeTypeName("SDL_JoystickID")] uint instance_id - ) => DllImport.OpenJoystick(instance_id); + public static void ReleaseCameraFrame(CameraHandle camera, Ref frame) => + DllImport.ReleaseCameraFrame(camera, frame); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - SensorHandle ISdl.OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => + void ISdl.ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer) => ( - (delegate* unmanaged)( - _slots[587] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[789] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[587] = nativeContext.LoadFunction("SDL_OpenSensor", "SDL3") + : _slots[789] = nativeContext.LoadFunction("SDL_ReleaseGPUBuffer", "SDL3") ) - )(instance_id); + )(device, buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenSensor")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static SensorHandle OpenSensor([NativeTypeName("SDL_SensorID")] uint instance_id) => - DllImport.OpenSensor(instance_id); + public static void ReleaseGPUBuffer(GPUDeviceHandle device, GPUBufferHandle buffer) => + DllImport.ReleaseGPUBuffer(device, buffer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, - void* userdata + void ISdl.ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline ) => ( - (delegate* unmanaged)( - _slots[588] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[790] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[588] = nativeContext.LoadFunction("SDL_OpenStorage", "SDL3") + : _slots[790] = nativeContext.LoadFunction( + "SDL_ReleaseGPUComputePipeline", + "SDL3" + ) ) - )(iface, userdata); + )(device, compute_pipeline); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUComputePipeline")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] StorageInterface* iface, - void* userdata - ) => DllImport.OpenStorage(iface, userdata); + public static void ReleaseGPUComputePipeline( + GPUDeviceHandle device, + GPUComputePipelineHandle compute_pipeline + ) => DllImport.ReleaseGPUComputePipeline(device, compute_pipeline); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] Ref iface, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (StorageInterface* __dsl_iface = iface) - { - return (StorageHandle)((ISdl)this).OpenStorage(__dsl_iface, __dsl_userdata); - } - } + void ISdl.ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + ( + (delegate* unmanaged)( + _slots[791] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[791] = nativeContext.LoadFunction("SDL_ReleaseGPUFence", "SDL3") + ) + )(device, fence); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUFence")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenStorage( - [NativeTypeName("const SDL_StorageInterface *")] Ref iface, - Ref userdata - ) => DllImport.OpenStorage(iface, userdata); + public static void ReleaseGPUFence(GPUDeviceHandle device, GPUFenceHandle fence) => + DllImport.ReleaseGPUFence(device, fence); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenTitleStorage( - [NativeTypeName("const char *")] sbyte* @override, - [NativeTypeName("SDL_PropertiesID")] uint props + void ISdl.ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline ) => ( - (delegate* unmanaged)( - _slots[589] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[792] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[589] = nativeContext.LoadFunction("SDL_OpenTitleStorage", "SDL3") + : _slots[792] = nativeContext.LoadFunction( + "SDL_ReleaseGPUGraphicsPipeline", + "SDL3" + ) ) - )(@override, props); + )(device, graphics_pipeline); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUGraphicsPipeline")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] sbyte* @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.OpenTitleStorage(@override, props); + public static void ReleaseGPUGraphicsPipeline( + GPUDeviceHandle device, + GPUGraphicsPipelineHandle graphics_pipeline + ) => DllImport.ReleaseGPUGraphicsPipeline(device, graphics_pipeline); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenTitleStorage( - [NativeTypeName("const char *")] Ref @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) - { - fixed (sbyte* __dsl_override = @override) - { - return (StorageHandle)((ISdl)this).OpenTitleStorage(__dsl_override, props); - } - } + void ISdl.ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler) => + ( + (delegate* unmanaged)( + _slots[793] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[793] = nativeContext.LoadFunction("SDL_ReleaseGPUSampler", "SDL3") + ) + )(device, sampler); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenTitleStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUSampler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenTitleStorage( - [NativeTypeName("const char *")] Ref @override, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.OpenTitleStorage(@override, props); + public static void ReleaseGPUSampler(GPUDeviceHandle device, GPUSamplerHandle sampler) => + DllImport.ReleaseGPUSampler(device, sampler); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.OpenURL([NativeTypeName("const char *")] sbyte* url) => + void ISdl.ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader) => ( - (delegate* unmanaged)( - _slots[590] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[794] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[590] = nativeContext.LoadFunction("SDL_OpenURL", "SDL3") + : _slots[794] = nativeContext.LoadFunction("SDL_ReleaseGPUShader", "SDL3") ) - )(url); + )(device, shader); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUShader")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte OpenURL([NativeTypeName("const char *")] sbyte* url) => - DllImport.OpenURL(url); + public static void ReleaseGPUShader(GPUDeviceHandle device, GPUShaderHandle shader) => + DllImport.ReleaseGPUShader(device, shader); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.OpenURL([NativeTypeName("const char *")] Ref url) - { - fixed (sbyte* __dsl_url = url) - { - return (MaybeBool)(byte)((ISdl)this).OpenURL(__dsl_url); - } - } + void ISdl.ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture) => + ( + (delegate* unmanaged)( + _slots[795] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[795] = nativeContext.LoadFunction("SDL_ReleaseGPUTexture", "SDL3") + ) + )(device, texture); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenURL")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool OpenURL([NativeTypeName("const char *")] Ref url) => - DllImport.OpenURL(url); + public static void ReleaseGPUTexture(GPUDeviceHandle device, GPUTextureHandle texture) => + DllImport.ReleaseGPUTexture(device, texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenUserStorage( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app, - [NativeTypeName("SDL_PropertiesID")] uint props + void ISdl.ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer ) => ( - (delegate* unmanaged)( - _slots[591] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[796] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[591] = nativeContext.LoadFunction("SDL_OpenUserStorage", "SDL3") + : _slots[796] = nativeContext.LoadFunction( + "SDL_ReleaseGPUTransferBuffer", + "SDL3" + ) ) - )(org, app, props); + )(device, transfer_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseGPUTransferBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] sbyte* org, - [NativeTypeName("const char *")] sbyte* app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.OpenUserStorage(org, app, props); + public static void ReleaseGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => DllImport.ReleaseGPUTransferBuffer(device, transfer_buffer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - StorageHandle ISdl.OpenUserStorage( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) - { - fixed (sbyte* __dsl_app = app) - fixed (sbyte* __dsl_org = org) - { - return (StorageHandle)((ISdl)this).OpenUserStorage(__dsl_org, __dsl_app, props); - } - } + void ISdl.ReleaseWindowFromGPUDevice(GPUDeviceHandle device, WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[797] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[797] = nativeContext.LoadFunction( + "SDL_ReleaseWindowFromGPUDevice", + "SDL3" + ) + ) + )(device, window); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OpenUserStorage")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseWindowFromGPUDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static StorageHandle OpenUserStorage( - [NativeTypeName("const char *")] Ref org, - [NativeTypeName("const char *")] Ref app, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.OpenUserStorage(org, app, props); + public static void ReleaseWindowFromGPUDevice(GPUDeviceHandle device, WindowHandle window) => + DllImport.ReleaseWindowFromGPUDevice(device, window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.OutOfMemory() => (MaybeBool)(byte)((ISdl)this).OutOfMemoryRaw(); + MaybeBool ISdl.ReloadGamepadMappings() => + (MaybeBool)(byte)((ISdl)this).ReloadGamepadMappingsRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool OutOfMemory() => DllImport.OutOfMemory(); + public static MaybeBool ReloadGamepadMappings() => DllImport.ReloadGamepadMappings(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.OutOfMemoryRaw() => + byte ISdl.ReloadGamepadMappingsRaw() => ( (delegate* unmanaged)( - _slots[592] is not null and var loadedFnPtr + _slots[798] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[592] = nativeContext.LoadFunction("SDL_OutOfMemory", "SDL3") + : _slots[798] = nativeContext.LoadFunction("SDL_ReloadGamepadMappings", "SDL3") ) )(); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_OutOfMemory")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte OutOfMemoryRaw() => DllImport.OutOfMemoryRaw(); + public static byte ReloadGamepadMappingsRaw() => DllImport.ReloadGamepadMappingsRaw(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PauseAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - (MaybeBool)(byte)((ISdl)this).PauseAudioDeviceRaw(dev); + void ISdl.RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => + ( + (delegate* unmanaged)( + _slots[799] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[799] = nativeContext.LoadFunction("SDL_RemoveEventWatch", "SDL3") + ) + )(filter, userdata); + + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => DllImport.RemoveEventWatch(filter, userdata); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.RemoveEventWatch([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) + { + fixed (void* __dsl_userdata = userdata) + { + ((ISdl)this).RemoveEventWatch(filter, __dsl_userdata); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PauseAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => DllImport.PauseAudioDevice(dev); + public static void RemoveEventWatch( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => DllImport.RemoveEventWatch(filter, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + void ISdl.RemoveHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => ( - (delegate* unmanaged)( - _slots[593] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[800] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[593] = nativeContext.LoadFunction("SDL_PauseAudioDevice", "SDL3") + : _slots[800] = nativeContext.LoadFunction("SDL_RemoveHintCallback", "SDL3") ) - )(dev); + )(name, callback, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PauseAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - DllImport.PauseAudioDeviceRaw(dev); + public static void RemoveHintCallback( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + void* userdata + ) => DllImport.RemoveHintCallback(name, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PauseAudioStreamDevice(AudioStreamHandle stream) => - (MaybeBool)(byte)((ISdl)this).PauseAudioStreamDeviceRaw(stream); + void ISdl.RemoveHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_name = name) + { + ((ISdl)this).RemoveHintCallback(__dsl_name, callback, __dsl_userdata); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PauseAudioStreamDevice(AudioStreamHandle stream) => - DllImport.PauseAudioStreamDevice(stream); + public static void RemoveHintCallback( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("SDL_HintCallback")] HintCallback callback, + Ref userdata + ) => DllImport.RemoveHintCallback(name, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => + byte ISdl.RemovePath([NativeTypeName("const char *")] sbyte* path) => ( - (delegate* unmanaged)( - _slots[594] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[801] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[594] = nativeContext.LoadFunction("SDL_PauseAudioStreamDevice", "SDL3") + : _slots[801] = nativeContext.LoadFunction("SDL_RemovePath", "SDL3") ) - )(stream); + )(path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PauseAudioStreamDeviceRaw(AudioStreamHandle stream) => - DllImport.PauseAudioStreamDeviceRaw(stream); + public static byte RemovePath([NativeTypeName("const char *")] sbyte* path) => + DllImport.RemovePath(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PauseHaptic(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).PauseHapticRaw(haptic); + MaybeBool ISdl.RemovePath([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).RemovePath(__dsl_path); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PauseHaptic(HapticHandle haptic) => DllImport.PauseHaptic(haptic); + public static MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) => + DllImport.RemovePath(path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PauseHapticRaw(HapticHandle haptic) => + byte ISdl.RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => ( - (delegate* unmanaged)( - _slots[595] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[802] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[595] = nativeContext.LoadFunction("SDL_PauseHaptic", "SDL3") + : _slots[802] = nativeContext.LoadFunction("SDL_RemoveStoragePath", "SDL3") ) - )(haptic); + )(storage, path); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PauseHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PauseHapticRaw(HapticHandle haptic) => DllImport.PauseHapticRaw(haptic); + public static byte RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* path + ) => DllImport.RemoveStoragePath(storage, path); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.PeepEvents( - Event* events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => + MaybeBool ISdl.RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).RemoveStoragePath(storage, __dsl_path); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool RemoveStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref path + ) => DllImport.RemoveStoragePath(storage, path); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.RemoveSurfaceAlternateImages(Surface* surface) => ( - (delegate* unmanaged)( - _slots[596] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[803] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[596] = nativeContext.LoadFunction("SDL_PeepEvents", "SDL3") + : _slots[803] = nativeContext.LoadFunction( + "SDL_RemoveSurfaceAlternateImages", + "SDL3" + ) ) - )(events, numevents, action, minType, maxType); + )(surface); - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int PeepEvents( - Event* events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => DllImport.PeepEvents(events, numevents, action, minType, maxType); + public static void RemoveSurfaceAlternateImages(Surface* surface) => + DllImport.RemoveSurfaceAlternateImages(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.PeepEvents( - Ref events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) + void ISdl.RemoveSurfaceAlternateImages(Ref surface) { - fixed (Event* __dsl_events = events) + fixed (Surface* __dsl_surface = surface) { - return (int)((ISdl)this).PeepEvents(__dsl_events, numevents, action, minType, maxType); + ((ISdl)this).RemoveSurfaceAlternateImages(__dsl_surface); } } [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PeepEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int PeepEvents( - Ref events, - int numevents, - EventAction action, - [NativeTypeName("Uint32")] uint minType, - [NativeTypeName("Uint32")] uint maxType - ) => DllImport.PeepEvents(events, numevents, action, minType, maxType); + public static void RemoveSurfaceAlternateImages(Ref surface) => + DllImport.RemoveSurfaceAlternateImages(surface); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PlayHapticRumble( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => (MaybeBool)(byte)((ISdl)this).PlayHapticRumbleRaw(haptic, strength, length); + MaybeBool ISdl.RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => + (MaybeBool)(byte)((ISdl)this).RemoveTimerRaw(id); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PlayHapticRumble( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => DllImport.PlayHapticRumble(haptic, strength, length); + public static MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => + DllImport.RemoveTimer(id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PlayHapticRumbleRaw( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => + byte ISdl.RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => ( - (delegate* unmanaged)( - _slots[597] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[804] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[597] = nativeContext.LoadFunction("SDL_PlayHapticRumble", "SDL3") + : _slots[804] = nativeContext.LoadFunction("SDL_RemoveTimer", "SDL3") ) - )(haptic, strength, length); + )(id); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PlayHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PlayHapticRumbleRaw( - HapticHandle haptic, - float strength, - [NativeTypeName("Uint32")] uint length - ) => DllImport.PlayHapticRumbleRaw(haptic, strength, length); + public static byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => + DllImport.RemoveTimerRaw(id); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PollEvent(Event* @event) => + byte ISdl.RenamePath( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => ( - (delegate* unmanaged)( - _slots[598] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[805] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[598] = nativeContext.LoadFunction("SDL_PollEvent", "SDL3") + : _slots[805] = nativeContext.LoadFunction("SDL_RenamePath", "SDL3") ) - )(@event); + )(oldpath, newpath); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PollEvent(Event* @event) => DllImport.PollEvent(@event); + public static byte RenamePath( + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => DllImport.RenamePath(oldpath, newpath); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PollEvent(Ref @event) + MaybeBool ISdl.RenamePath( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) { - fixed (Event* __dsl_event = @event) + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) { - return (MaybeBool)(byte)((ISdl)this).PollEvent(__dsl_event); + return (MaybeBool)(byte)((ISdl)this).RenamePath(__dsl_oldpath, __dsl_newpath); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PollEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PollEvent(Ref @event) => DllImport.PollEvent(@event); + public static MaybeBool RenamePath( + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => DllImport.RenamePath(oldpath, newpath); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch, - [NativeTypeName("bool")] byte linear + byte ISdl.RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath ) => ( - (delegate* unmanaged< - int, - int, - PixelFormat, - void*, - int, - PixelFormat, - void*, - int, - byte, - byte>)( - _slots[599] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[806] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[599] = nativeContext.LoadFunction("SDL_PremultiplyAlpha", "SDL3") + : _slots[806] = nativeContext.LoadFunction("SDL_RenameStoragePath", "SDL3") ) - )(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch, linear); + )(storage, oldpath, newpath); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] void* src, - int src_pitch, - PixelFormat dst_format, - void* dst, - int dst_pitch, - [NativeTypeName("bool")] byte linear - ) => - DllImport.PremultiplyAlpha( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch, - linear - ); - + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch, - [NativeTypeName("bool")] MaybeBool linear + public static byte RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] sbyte* oldpath, + [NativeTypeName("const char *")] sbyte* newpath + ) => DllImport.RenameStoragePath(storage, oldpath, newpath); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath ) { - fixed (void* __dsl_dst = dst) - fixed (void* __dsl_src = src) + fixed (sbyte* __dsl_newpath = newpath) + fixed (sbyte* __dsl_oldpath = oldpath) { return (MaybeBool) - (byte) - ((ISdl)this).PremultiplyAlpha( - width, - height, - src_format, - __dsl_src, - src_pitch, - dst_format, - __dsl_dst, - dst_pitch, - (byte)linear - ); + (byte)((ISdl)this).RenameStoragePath(storage, __dsl_oldpath, __dsl_newpath); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplyAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PremultiplyAlpha( - int width, - int height, - PixelFormat src_format, - [NativeTypeName("const void *")] Ref src, - int src_pitch, - PixelFormat dst_format, - Ref dst, - int dst_pitch, - [NativeTypeName("bool")] MaybeBool linear - ) => - DllImport.PremultiplyAlpha( - width, - height, - src_format, - src, - src_pitch, - dst_format, - dst, - dst_pitch, - linear - ); + public static MaybeBool RenameStoragePath( + StorageHandle storage, + [NativeTypeName("const char *")] Ref oldpath, + [NativeTypeName("const char *")] Ref newpath + ) => DllImport.RenameStoragePath(storage, oldpath, newpath); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PremultiplySurfaceAlpha(Surface* surface, [NativeTypeName("bool")] byte linear) => + MaybeBool ISdl.RenderClear(RendererHandle renderer) => + (MaybeBool)(byte)((ISdl)this).RenderClearRaw(renderer); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool RenderClear(RendererHandle renderer) => + DllImport.RenderClear(renderer); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.RenderClearRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[600] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[807] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[600] = nativeContext.LoadFunction( - "SDL_PremultiplySurfaceAlpha", - "SDL3" - ) + : _slots[807] = nativeContext.LoadFunction("SDL_RenderClear", "SDL3") ) - )(surface, linear); + )(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PremultiplySurfaceAlpha( - Surface* surface, - [NativeTypeName("bool")] byte linear - ) => DllImport.PremultiplySurfaceAlpha(surface, linear); + public static byte RenderClearRaw(RendererHandle renderer) => + DllImport.RenderClearRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PremultiplySurfaceAlpha( - Ref surface, - [NativeTypeName("bool")] MaybeBool linear - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).PremultiplySurfaceAlpha(__dsl_surface, (byte)linear); - } - } + MaybeBool ISdl.RenderClipEnabled(RendererHandle renderer) => + (MaybeBool)(byte)((ISdl)this).RenderClipEnabledRaw(renderer); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PremultiplySurfaceAlpha")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PremultiplySurfaceAlpha( - Ref surface, - [NativeTypeName("bool")] MaybeBool linear - ) => DllImport.PremultiplySurfaceAlpha(surface, linear); + public static MaybeBool RenderClipEnabled(RendererHandle renderer) => + DllImport.RenderClipEnabled(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.PumpEvents() => + byte ISdl.RenderClipEnabledRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[601] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[808] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[601] = nativeContext.LoadFunction("SDL_PumpEvents", "SDL3") + : _slots[808] = nativeContext.LoadFunction("SDL_RenderClipEnabled", "SDL3") ) - )(); + )(renderer); - [NativeFunction("SDL3", EntryPoint = "SDL_PumpEvents")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void PumpEvents() => DllImport.PumpEvents(); + public static byte RenderClipEnabledRaw(RendererHandle renderer) => + DllImport.RenderClipEnabledRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PushEvent(Event* @event) => + byte ISdl.RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + float* x, + float* y + ) => ( - (delegate* unmanaged)( - _slots[602] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[809] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[602] = nativeContext.LoadFunction("SDL_PushEvent", "SDL3") + : _slots[809] = nativeContext.LoadFunction( + "SDL_RenderCoordinatesFromWindow", + "SDL3" + ) ) - )(@event); + )(renderer, window_x, window_y, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PushEvent(Event* @event) => DllImport.PushEvent(@event); + public static byte RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + float* x, + float* y + ) => DllImport.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PushEvent(Ref @event) + MaybeBool ISdl.RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + Ref x, + Ref y + ) { - fixed (Event* __dsl_event = @event) + fixed (float* __dsl_y = y) + fixed (float* __dsl_x = x) { - return (MaybeBool)(byte)((ISdl)this).PushEvent(__dsl_event); + return (MaybeBool) + (byte) + ((ISdl)this).RenderCoordinatesFromWindow( + renderer, + window_x, + window_y, + __dsl_x, + __dsl_y + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PushEvent")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PushEvent(Ref @event) => DllImport.PushEvent(@event); + public static MaybeBool RenderCoordinatesFromWindow( + RendererHandle renderer, + float window_x, + float window_y, + Ref x, + Ref y + ) => DllImport.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] void* buf, - int len + byte ISdl.RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + float* window_x, + float* window_y ) => ( - (delegate* unmanaged)( - _slots[603] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[810] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[603] = nativeContext.LoadFunction("SDL_PutAudioStreamData", "SDL3") + : _slots[810] = nativeContext.LoadFunction( + "SDL_RenderCoordinatesToWindow", + "SDL3" + ) ) - )(stream, buf, len); + )(renderer, x, y, window_x, window_y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] void* buf, - int len - ) => DllImport.PutAudioStreamData(stream, buf, len); + public static byte RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + float* window_x, + float* window_y + ) => DllImport.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] Ref buf, - int len + MaybeBool ISdl.RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + Ref window_x, + Ref window_y ) { - fixed (void* __dsl_buf = buf) + fixed (float* __dsl_window_y = window_y) + fixed (float* __dsl_window_x = window_x) { - return (MaybeBool)(byte)((ISdl)this).PutAudioStreamData(stream, __dsl_buf, len); + return (MaybeBool) + (byte) + ((ISdl)this).RenderCoordinatesToWindow( + renderer, + x, + y, + __dsl_window_x, + __dsl_window_y + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_PutAudioStreamData")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool PutAudioStreamData( - AudioStreamHandle stream, - [NativeTypeName("const void *")] Ref buf, - int len - ) => DllImport.PutAudioStreamData(stream, buf, len); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.Quit() => - ( - (delegate* unmanaged)( - _slots[604] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[604] = nativeContext.LoadFunction("SDL_Quit", "SDL3") - ) - )(); - - [NativeFunction("SDL3", EntryPoint = "SDL_Quit")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void Quit() => DllImport.Quit(); + public static MaybeBool RenderCoordinatesToWindow( + RendererHandle renderer, + float x, + float y, + Ref window_x, + Ref window_y + ) => DllImport.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => + byte ISdl.RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] sbyte* str + ) => ( - (delegate* unmanaged)( - _slots[605] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[811] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[605] = nativeContext.LoadFunction("SDL_QuitSubSystem", "SDL3") + : _slots[811] = nativeContext.LoadFunction("SDL_RenderDebugText", "SDL3") ) - )(flags); + )(renderer, x, y, str); - [NativeFunction("SDL3", EntryPoint = "SDL_QuitSubSystem")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void QuitSubSystem([NativeTypeName("SDL_InitFlags")] uint flags) => - DllImport.QuitSubSystem(flags); + public static byte RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] sbyte* str + ) => DllImport.RenderDebugText(renderer, x, y, str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RaiseWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).RaiseWindowRaw(window); + MaybeBool ISdl.RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] Ref str + ) + { + fixed (sbyte* __dsl_str = str) + { + return (MaybeBool)(byte)((ISdl)this).RenderDebugText(renderer, x, y, __dsl_str); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RaiseWindow(WindowHandle window) => DllImport.RaiseWindow(window); + public static MaybeBool RenderDebugText( + RendererHandle renderer, + float x, + float y, + [NativeTypeName("const char *")] Ref str + ) => DllImport.RenderDebugText(renderer, x, y, str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RaiseWindowRaw(WindowHandle window) => + byte ISdl.RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => ( - (delegate* unmanaged)( - _slots[606] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[812] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[606] = nativeContext.LoadFunction("SDL_RaiseWindow", "SDL3") + : _slots[812] = nativeContext.LoadFunction("SDL_RenderFillRect", "SDL3") ) - )(window); + )(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RaiseWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RaiseWindowRaw(WindowHandle window) => DllImport.RaiseWindowRaw(window); + public static byte RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => DllImport.RenderFillRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - nuint ISdl.ReadIO(IOStreamHandle context, void* ptr, [NativeTypeName("size_t")] nuint size) => + MaybeBool ISdl.RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) + { + fixed (FRect* __dsl_rect = rect) + { + return (MaybeBool)(byte)((ISdl)this).RenderFillRect(renderer, __dsl_rect); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool RenderFillRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) => DllImport.RenderFillRect(renderer, rect); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => ( - (delegate* unmanaged)( - _slots[607] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[813] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[607] = nativeContext.LoadFunction("SDL_ReadIO", "SDL3") + : _slots[813] = nativeContext.LoadFunction("SDL_RenderFillRects", "SDL3") ) - )(context, ptr, size); + )(renderer, rects, count); - [return: NativeTypeName("size_t")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static nuint ReadIO( - IOStreamHandle context, - void* ptr, - [NativeTypeName("size_t")] nuint size - ) => DllImport.ReadIO(context, ptr, size); + public static byte RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => DllImport.RenderFillRects(renderer, rects, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - nuint ISdl.ReadIO(IOStreamHandle context, Ref ptr, [NativeTypeName("size_t")] nuint size) + MaybeBool ISdl.RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) { - fixed (void* __dsl_ptr = ptr) + fixed (FRect* __dsl_rects = rects) { - return (nuint)((ISdl)this).ReadIO(context, __dsl_ptr, size); + return (MaybeBool) + (byte)((ISdl)this).RenderFillRects(renderer, __dsl_rects, count); } } - [return: NativeTypeName("size_t")] + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static nuint ReadIO( - IOStreamHandle context, - Ref ptr, - [NativeTypeName("size_t")] nuint size - ) => DllImport.ReadIO(context, ptr, size); + public static MaybeBool RenderFillRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) => DllImport.RenderFillRects(renderer, rects, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + byte ISdl.RenderGeometry( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, + int num_vertices, + [NativeTypeName("const int *")] int* indices, + int num_indices + ) => ( - (delegate* unmanaged)( - _slots[608] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[814] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[608] = nativeContext.LoadFunction("SDL_ReadS16BE", "SDL3") + : _slots[814] = nativeContext.LoadFunction("SDL_RenderGeometry", "SDL3") ) - )(src, value); + )(renderer, texture, vertices, num_vertices, indices, num_indices); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS16BE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => - DllImport.ReadS16BE(src, value); + public static byte RenderGeometry( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, + int num_vertices, + [NativeTypeName("const int *")] int* indices, + int num_indices + ) => DllImport.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS16BE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value + MaybeBool ISdl.RenderGeometry( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_Vertex *")] Ref vertices, + int num_vertices, + [NativeTypeName("const int *")] Ref indices, + int num_indices ) { - fixed (short* __dsl_value = value) + fixed (int* __dsl_indices = indices) + fixed (Vertex* __dsl_vertices = vertices) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadS16BE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderGeometry( + renderer, + __dsl_texture, + __dsl_vertices, + num_vertices, + __dsl_indices, + num_indices + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS16BE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value - ) => DllImport.ReadS16BE(src, value); + public static MaybeBool RenderGeometry( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_Vertex *")] Ref vertices, + int num_vertices, + [NativeTypeName("const int *")] Ref indices, + int num_indices + ) => DllImport.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => + byte ISdl.RenderGeometryRaw( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const float *")] float* xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] FColor* color, + int color_stride, + [NativeTypeName("const float *")] float* uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] void* indices, + int num_indices, + int size_indices + ) => ( - (delegate* unmanaged)( - _slots[609] is not null and var loadedFnPtr + (delegate* unmanaged< + RendererHandle, + Texture*, + float*, + int, + FColor*, + int, + float*, + int, + int, + void*, + int, + int, + byte>)( + _slots[815] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[609] = nativeContext.LoadFunction("SDL_ReadS16LE", "SDL3") + : _slots[815] = nativeContext.LoadFunction("SDL_RenderGeometryRaw", "SDL3") ) - )(src, value); + )( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS16LE(IOStreamHandle src, [NativeTypeName("Sint16 *")] short* value) => - DllImport.ReadS16LE(src, value); + public static byte RenderGeometryRaw( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const float *")] float* xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] FColor* color, + int color_stride, + [NativeTypeName("const float *")] float* uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] void* indices, + int num_indices, + int size_indices + ) => + DllImport.RenderGeometryRaw( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS16LE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value + MaybeBool ISdl.RenderGeometryRaw( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const float *")] Ref xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] Ref color, + int color_stride, + [NativeTypeName("const float *")] Ref uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] Ref indices, + int num_indices, + int size_indices ) { - fixed (short* __dsl_value = value) + fixed (void* __dsl_indices = indices) + fixed (float* __dsl_uv = uv) + fixed (FColor* __dsl_color = color) + fixed (float* __dsl_xy = xy) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadS16LE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderGeometryRaw( + renderer, + __dsl_texture, + __dsl_xy, + xy_stride, + __dsl_color, + color_stride, + __dsl_uv, + uv_stride, + num_vertices, + __dsl_indices, + num_indices, + size_indices + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS16LE")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS16LE( - IOStreamHandle src, - [NativeTypeName("Sint16 *")] Ref value - ) => DllImport.ReadS16LE(src, value); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - ( - (delegate* unmanaged)( - _slots[610] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[610] = nativeContext.LoadFunction("SDL_ReadS32BE", "SDL3") - ) - )(src, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - DllImport.ReadS32BE(src, value); + public static MaybeBool RenderGeometryRaw( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const float *")] Ref xy, + int xy_stride, + [NativeTypeName("const SDL_FColor *")] Ref color, + int color_stride, + [NativeTypeName("const float *")] Ref uv, + int uv_stride, + int num_vertices, + [NativeTypeName("const void *")] Ref indices, + int num_indices, + int size_indices + ) => + DllImport.RenderGeometryRaw( + renderer, + texture, + xy, + xy_stride, + color, + color_stride, + uv, + uv_stride, + num_vertices, + indices, + num_indices, + size_indices + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS32BE(IOStreamHandle src, [NativeTypeName("Sint32 *")] Ref value) - { - fixed (int* __dsl_value = value) - { - return (MaybeBool)(byte)((ISdl)this).ReadS32BE(src, __dsl_value); - } - } + MaybeBool ISdl.RenderLine( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => (MaybeBool)(byte)((ISdl)this).RenderLineRaw(renderer, x1, y1, x2, y2); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS32BE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) => DllImport.ReadS32BE(src, value); + public static MaybeBool RenderLine( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => DllImport.RenderLine(renderer, x1, y1, x2, y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => + byte ISdl.RenderLineRaw(RendererHandle renderer, float x1, float y1, float x2, float y2) => ( - (delegate* unmanaged)( - _slots[611] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[816] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[611] = nativeContext.LoadFunction("SDL_ReadS32LE", "SDL3") + : _slots[816] = nativeContext.LoadFunction("SDL_RenderLine", "SDL3") ) - )(src, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] int* value) => - DllImport.ReadS32LE(src, value); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS32LE(IOStreamHandle src, [NativeTypeName("Sint32 *")] Ref value) - { - fixed (int* __dsl_value = value) - { - return (MaybeBool)(byte)((ISdl)this).ReadS32LE(src, __dsl_value); - } - } + )(renderer, x1, y1, x2, y2); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS32LE( - IOStreamHandle src, - [NativeTypeName("Sint32 *")] Ref value - ) => DllImport.ReadS32LE(src, value); + public static byte RenderLineRaw( + RendererHandle renderer, + float x1, + float y1, + float x2, + float y2 + ) => DllImport.RenderLineRaw(renderer, x1, y1, x2, y2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => + byte ISdl.RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => ( - (delegate* unmanaged)( - _slots[612] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[817] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[612] = nativeContext.LoadFunction("SDL_ReadS64BE", "SDL3") + : _slots[817] = nativeContext.LoadFunction("SDL_RenderLines", "SDL3") ) - )(src, value); + )(renderer, points, count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => - DllImport.ReadS64BE(src, value); + public static byte RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => DllImport.RenderLines(renderer, points, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS64BE(IOStreamHandle src, [NativeTypeName("Sint64 *")] Ref value) + MaybeBool ISdl.RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) { - fixed (long* __dsl_value = value) + fixed (FPoint* __dsl_points = points) { - return (MaybeBool)(byte)((ISdl)this).ReadS64BE(src, __dsl_value); + return (MaybeBool)(byte)((ISdl)this).RenderLines(renderer, __dsl_points, count); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64BE")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS64BE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) => DllImport.ReadS64BE(src, value); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => - ( - (delegate* unmanaged)( - _slots[613] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[613] = nativeContext.LoadFunction("SDL_ReadS64LE", "SDL3") - ) - )(src, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] long* value) => - DllImport.ReadS64LE(src, value); + public static MaybeBool RenderLines( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) => DllImport.RenderLines(renderer, points, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS64LE(IOStreamHandle src, [NativeTypeName("Sint64 *")] Ref value) - { - fixed (long* __dsl_value = value) - { - return (MaybeBool)(byte)((ISdl)this).ReadS64LE(src, __dsl_value); - } - } + MaybeBool ISdl.RenderPoint(RendererHandle renderer, float x, float y) => + (MaybeBool)(byte)((ISdl)this).RenderPointRaw(renderer, x, y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS64LE( - IOStreamHandle src, - [NativeTypeName("Sint64 *")] Ref value - ) => DllImport.ReadS64LE(src, value); + public static MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => + DllImport.RenderPoint(renderer, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => + byte ISdl.RenderPointRaw(RendererHandle renderer, float x, float y) => ( - (delegate* unmanaged)( - _slots[614] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[818] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[614] = nativeContext.LoadFunction("SDL_ReadS8", "SDL3") + : _slots[818] = nativeContext.LoadFunction("SDL_RenderPoint", "SDL3") ) - )(src, value); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] sbyte* value) => - DllImport.ReadS8(src, value); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadS8(IOStreamHandle src, [NativeTypeName("Sint8 *")] Ref value) - { - fixed (sbyte* __dsl_value = value) - { - return (MaybeBool)(byte)((ISdl)this).ReadS8(src, __dsl_value); - } - } + )(renderer, x, y); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadS8")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadS8( - IOStreamHandle src, - [NativeTypeName("Sint8 *")] Ref value - ) => DllImport.ReadS8(src, value); + public static byte RenderPointRaw(RendererHandle renderer, float x, float y) => + DllImport.RenderPointRaw(renderer, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - void* destination, - [NativeTypeName("Uint64")] ulong length + byte ISdl.RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count ) => ( - (delegate* unmanaged)( - _slots[615] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[819] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[615] = nativeContext.LoadFunction("SDL_ReadStorageFile", "SDL3") + : _slots[819] = nativeContext.LoadFunction("SDL_RenderPoints", "SDL3") ) - )(storage, path, destination, length); + )(renderer, points, count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path, - void* destination, - [NativeTypeName("Uint64")] ulong length - ) => DllImport.ReadStorageFile(storage, path, destination, length); + public static byte RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] FPoint* points, + int count + ) => DllImport.RenderPoints(renderer, points, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref destination, - [NativeTypeName("Uint64")] ulong length + MaybeBool ISdl.RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count ) { - fixed (void* __dsl_destination = destination) - fixed (sbyte* __dsl_path = path) + fixed (FPoint* __dsl_points = points) { - return (MaybeBool) - (byte)((ISdl)this).ReadStorageFile(storage, __dsl_path, __dsl_destination, length); + return (MaybeBool)(byte)((ISdl)this).RenderPoints(renderer, __dsl_points, count); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadStorageFile")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadStorageFile( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path, - Ref destination, - [NativeTypeName("Uint64")] ulong length - ) => DllImport.ReadStorageFile(storage, path, destination, length); + public static MaybeBool RenderPoints( + RendererHandle renderer, + [NativeTypeName("const SDL_FPoint *")] Ref points, + int count + ) => DllImport.RenderPoints(renderer, points, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => - ( - (delegate* unmanaged)( - _slots[616] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[616] = nativeContext.LoadFunction("SDL_ReadSurfacePixel", "SDL3") - ) - )(surface, x, y, r, g, b, a); + MaybeBool ISdl.RenderPresent(RendererHandle renderer) => + (MaybeBool)(byte)((ISdl)this).RenderPresentRaw(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadSurfacePixel( - Surface* surface, - int x, - int y, - [NativeTypeName("Uint8 *")] byte* r, - [NativeTypeName("Uint8 *")] byte* g, - [NativeTypeName("Uint8 *")] byte* b, - [NativeTypeName("Uint8 *")] byte* a - ) => DllImport.ReadSurfacePixel(surface, x, y, r, g, b, a); + public static MaybeBool RenderPresent(RendererHandle renderer) => + DllImport.RenderPresent(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) - { - fixed (byte* __dsl_a = a) - fixed (byte* __dsl_b = b) - fixed (byte* __dsl_g = g) - fixed (byte* __dsl_r = r) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte) - ((ISdl)this).ReadSurfacePixel( - __dsl_surface, - x, - y, - __dsl_r, - __dsl_g, - __dsl_b, - __dsl_a - ); - } - } + byte ISdl.RenderPresentRaw(RendererHandle renderer) => + ( + (delegate* unmanaged)( + _slots[820] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[820] = nativeContext.LoadFunction("SDL_RenderPresent", "SDL3") + ) + )(renderer); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixel")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadSurfacePixel( - Ref surface, - int x, - int y, - [NativeTypeName("Uint8 *")] Ref r, - [NativeTypeName("Uint8 *")] Ref g, - [NativeTypeName("Uint8 *")] Ref b, - [NativeTypeName("Uint8 *")] Ref a - ) => DllImport.ReadSurfacePixel(surface, x, y, r, g, b, a); + public static byte RenderPresentRaw(RendererHandle renderer) => + DllImport.RenderPresentRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadSurfacePixelFloat( - Surface* surface, - int x, - int y, - float* r, - float* g, - float* b, - float* a + Surface* ISdl.RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect ) => ( - (delegate* unmanaged)( - _slots[617] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[821] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[617] = nativeContext.LoadFunction("SDL_ReadSurfacePixelFloat", "SDL3") + : _slots[821] = nativeContext.LoadFunction("SDL_RenderReadPixels", "SDL3") ) - )(surface, x, y, r, g, b, a); + )(renderer, rect); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadSurfacePixelFloat( - Surface* surface, - int x, - int y, - float* r, - float* g, - float* b, - float* a - ) => DllImport.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); + public static Surface* RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => DllImport.RenderReadPixels(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadSurfacePixelFloat( - Ref surface, - int x, - int y, - Ref r, - Ref g, - Ref b, - Ref a + Ptr ISdl.RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect ) { - fixed (float* __dsl_a = a) - fixed (float* __dsl_b = b) - fixed (float* __dsl_g = g) - fixed (float* __dsl_r = r) - fixed (Surface* __dsl_surface = surface) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte) - ((ISdl)this).ReadSurfacePixelFloat( - __dsl_surface, - x, - y, - __dsl_r, - __dsl_g, - __dsl_b, - __dsl_a - ); + return (Surface*)((ISdl)this).RenderReadPixels(renderer, __dsl_rect); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadSurfacePixelFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadSurfacePixelFloat( - Ref surface, - int x, - int y, - Ref r, - Ref g, - Ref b, - Ref a - ) => DllImport.ReadSurfacePixelFloat(surface, x, y, r, g, b, a); + public static Ptr RenderReadPixels( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => DllImport.RenderReadPixels(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => - ( - (delegate* unmanaged)( - _slots[618] is not null and var loadedFnPtr + byte ISdl.RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => + ( + (delegate* unmanaged)( + _slots[822] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[618] = nativeContext.LoadFunction("SDL_ReadU16BE", "SDL3") + : _slots[822] = nativeContext.LoadFunction("SDL_RenderRect", "SDL3") ) - )(src, value); + )(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU16BE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => - DllImport.ReadU16BE(src, value); + public static byte RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rect + ) => DllImport.RenderRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU16BE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value + MaybeBool ISdl.RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect ) { - fixed (ushort* __dsl_value = value) + fixed (FRect* __dsl_rect = rect) { - return (MaybeBool)(byte)((ISdl)this).ReadU16BE(src, __dsl_value); + return (MaybeBool)(byte)((ISdl)this).RenderRect(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU16BE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) => DllImport.ReadU16BE(src, value); + public static MaybeBool RenderRect( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rect + ) => DllImport.RenderRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => + byte ISdl.RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => ( - (delegate* unmanaged)( - _slots[619] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[823] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[619] = nativeContext.LoadFunction("SDL_ReadU16LE", "SDL3") + : _slots[823] = nativeContext.LoadFunction("SDL_RenderRects", "SDL3") ) - )(src, value); + )(renderer, rects, count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU16LE(IOStreamHandle src, [NativeTypeName("Uint16 *")] ushort* value) => - DllImport.ReadU16LE(src, value); + public static byte RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] FRect* rects, + int count + ) => DllImport.RenderRects(renderer, rects, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU16LE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value + MaybeBool ISdl.RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count ) { - fixed (ushort* __dsl_value = value) + fixed (FRect* __dsl_rects = rects) { - return (MaybeBool)(byte)((ISdl)this).ReadU16LE(src, __dsl_value); + return (MaybeBool)(byte)((ISdl)this).RenderRects(renderer, __dsl_rects, count); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU16LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU16LE( - IOStreamHandle src, - [NativeTypeName("Uint16 *")] Ref value - ) => DllImport.ReadU16LE(src, value); + public static MaybeBool RenderRects( + RendererHandle renderer, + [NativeTypeName("const SDL_FRect *")] Ref rects, + int count + ) => DllImport.RenderRects(renderer, rects, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + byte ISdl.RenderTexture( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => ( - (delegate* unmanaged)( - _slots[620] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[824] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[620] = nativeContext.LoadFunction("SDL_ReadU32BE", "SDL3") + : _slots[824] = nativeContext.LoadFunction("SDL_RenderTexture", "SDL3") ) - )(src, value); + )(renderer, texture, srcrect, dstrect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => - DllImport.ReadU32BE(src, value); + public static byte RenderTexture( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => DllImport.RenderTexture(renderer, texture, srcrect, dstrect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU32BE(IOStreamHandle src, [NativeTypeName("Uint32 *")] Ref value) + MaybeBool ISdl.RenderTexture( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) { - fixed (uint* __dsl_value = value) + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadU32BE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderTexture( + renderer, + __dsl_texture, + __dsl_srcrect, + __dsl_dstrect + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU32BE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) => DllImport.ReadU32BE(src, value); + public static MaybeBool RenderTexture( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => DllImport.RenderTexture(renderer, texture, srcrect, dstrect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => + byte ISdl.RenderTexture9Grid( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => ( - (delegate* unmanaged)( - _slots[621] is not null and var loadedFnPtr + (delegate* unmanaged< + RendererHandle, + Texture*, + FRect*, + float, + float, + float, + float, + float, + FRect*, + byte>)( + _slots[825] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[621] = nativeContext.LoadFunction("SDL_ReadU32LE", "SDL3") + : _slots[825] = nativeContext.LoadFunction("SDL_RenderTexture9Grid", "SDL3") ) - )(src, value); + )( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] uint* value) => - DllImport.ReadU32LE(src, value); + public static byte RenderTexture9Grid( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => + DllImport.RenderTexture9Grid( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU32LE(IOStreamHandle src, [NativeTypeName("Uint32 *")] Ref value) + MaybeBool ISdl.RenderTexture9Grid( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) { - fixed (uint* __dsl_value = value) + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadU32LE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderTexture9Grid( + renderer, + __dsl_texture, + __dsl_srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + __dsl_dstrect + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU32LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU32LE( - IOStreamHandle src, - [NativeTypeName("Uint32 *")] Ref value - ) => DllImport.ReadU32LE(src, value); + public static MaybeBool RenderTexture9Grid( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float left_width, + float right_width, + float top_height, + float bottom_height, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => + DllImport.RenderTexture9Grid( + renderer, + texture, + srcrect, + left_width, + right_width, + top_height, + bottom_height, + scale, + dstrect + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + byte ISdl.RenderTextureRotated( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] FPoint* center, + FlipMode flip + ) => ( - (delegate* unmanaged)( - _slots[622] is not null and var loadedFnPtr + (delegate* unmanaged< + RendererHandle, + Texture*, + FRect*, + FRect*, + double, + FPoint*, + FlipMode, + byte>)( + _slots[826] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[622] = nativeContext.LoadFunction("SDL_ReadU64BE", "SDL3") + : _slots[826] = nativeContext.LoadFunction("SDL_RenderTextureRotated", "SDL3") ) - )(src, value); + )(renderer, texture, srcrect, dstrect, angle, center, flip); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU64BE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => - DllImport.ReadU64BE(src, value); + public static byte RenderTextureRotated( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] FPoint* center, + FlipMode flip + ) => DllImport.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU64BE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value + MaybeBool ISdl.RenderTextureRotated( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] Ref center, + FlipMode flip ) { - fixed (ulong* __dsl_value = value) + fixed (FPoint* __dsl_center = center) + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadU64BE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderTextureRotated( + renderer, + __dsl_texture, + __dsl_srcrect, + __dsl_dstrect, + angle, + __dsl_center, + flip + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64BE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU64BE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value - ) => DllImport.ReadU64BE(src, value); + public static MaybeBool RenderTextureRotated( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + [NativeTypeName("const SDL_FRect *")] Ref dstrect, + double angle, + [NativeTypeName("const SDL_FPoint *")] Ref center, + FlipMode flip + ) => DllImport.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => + byte ISdl.RenderTextureTiled( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => ( - (delegate* unmanaged)( - _slots[623] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[827] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[623] = nativeContext.LoadFunction("SDL_ReadU64LE", "SDL3") + : _slots[827] = nativeContext.LoadFunction("SDL_RenderTextureTiled", "SDL3") ) - )(src, value); + )(renderer, texture, srcrect, scale, dstrect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU64LE(IOStreamHandle src, [NativeTypeName("Uint64 *")] ulong* value) => - DllImport.ReadU64LE(src, value); + public static byte RenderTextureTiled( + RendererHandle renderer, + Texture* texture, + [NativeTypeName("const SDL_FRect *")] FRect* srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] FRect* dstrect + ) => DllImport.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU64LE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value + MaybeBool ISdl.RenderTextureTiled( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect ) { - fixed (ulong* __dsl_value = value) + fixed (FRect* __dsl_dstrect = dstrect) + fixed (FRect* __dsl_srcrect = srcrect) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).ReadU64LE(src, __dsl_value); + return (MaybeBool) + (byte) + ((ISdl)this).RenderTextureTiled( + renderer, + __dsl_texture, + __dsl_srcrect, + scale, + __dsl_dstrect + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU64LE")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU64LE( - IOStreamHandle src, - [NativeTypeName("Uint64 *")] Ref value - ) => DllImport.ReadU64LE(src, value); + public static MaybeBool RenderTextureTiled( + RendererHandle renderer, + Ref texture, + [NativeTypeName("const SDL_FRect *")] Ref srcrect, + float scale, + [NativeTypeName("const SDL_FRect *")] Ref dstrect + ) => DllImport.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => + MaybeBool ISdl.RenderViewportSet(RendererHandle renderer) => + (MaybeBool)(byte)((ISdl)this).RenderViewportSetRaw(renderer); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool RenderViewportSet(RendererHandle renderer) => + DllImport.RenderViewportSet(renderer); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.RenderViewportSetRaw(RendererHandle renderer) => ( - (delegate* unmanaged)( - _slots[624] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[828] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[624] = nativeContext.LoadFunction("SDL_ReadU8", "SDL3") + : _slots[828] = nativeContext.LoadFunction("SDL_RenderViewportSet", "SDL3") ) - )(src, value); + )(renderer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] byte* value) => - DllImport.ReadU8(src, value); + public static byte RenderViewportSetRaw(RendererHandle renderer) => + DllImport.RenderViewportSetRaw(renderer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReadU8(IOStreamHandle src, [NativeTypeName("Uint8 *")] Ref value) + AssertState ISdl.ReportAssertion( + AssertData* data, + [NativeTypeName("const char *")] sbyte* func, + [NativeTypeName("const char *")] sbyte* file, + int line + ) => + ( + (delegate* unmanaged)( + _slots[829] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[829] = nativeContext.LoadFunction("SDL_ReportAssertion", "SDL3") + ) + )(data, func, file, line); + + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static AssertState ReportAssertion( + AssertData* data, + [NativeTypeName("const char *")] sbyte* func, + [NativeTypeName("const char *")] sbyte* file, + int line + ) => DllImport.ReportAssertion(data, func, file, line); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + AssertState ISdl.ReportAssertion( + Ref data, + [NativeTypeName("const char *")] Ref func, + [NativeTypeName("const char *")] Ref file, + int line + ) { - fixed (byte* __dsl_value = value) + fixed (sbyte* __dsl_file = file) + fixed (sbyte* __dsl_func = func) + fixed (AssertData* __dsl_data = data) { - return (MaybeBool)(byte)((ISdl)this).ReadU8(src, __dsl_value); + return (AssertState) + ((ISdl)this).ReportAssertion(__dsl_data, __dsl_func, __dsl_file, line); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReadU8")] + [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReadU8( - IOStreamHandle src, - [NativeTypeName("Uint8 *")] Ref value - ) => DllImport.ReadU8(src, value); + public static AssertState ReportAssertion( + Ref data, + [NativeTypeName("const char *")] Ref func, + [NativeTypeName("const char *")] Ref file, + int line + ) => DllImport.ReportAssertion(data, func, file, line); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.RegisterEvents(int numevents) => + void ISdl.ResetAssertionReport() => ( - (delegate* unmanaged)( - _slots[625] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[830] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[625] = nativeContext.LoadFunction("SDL_RegisterEvents", "SDL3") + : _slots[830] = nativeContext.LoadFunction("SDL_ResetAssertionReport", "SDL3") ) - )(numevents); + )(); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_RegisterEvents")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint RegisterEvents(int numevents) => DllImport.RegisterEvents(numevents); + public static void ResetAssertionReport() => DllImport.ResetAssertionReport(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ReleaseCameraFrame(CameraHandle camera, Surface* frame) => + byte ISdl.ResetHint([NativeTypeName("const char *")] sbyte* name) => ( - (delegate* unmanaged)( - _slots[626] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[831] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[626] = nativeContext.LoadFunction("SDL_ReleaseCameraFrame", "SDL3") + : _slots[831] = nativeContext.LoadFunction("SDL_ResetHint", "SDL3") ) - )(camera, frame); - - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ReleaseCameraFrame(CameraHandle camera, Surface* frame) => - DllImport.ReleaseCameraFrame(camera, frame); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ReleaseCameraFrame(CameraHandle camera, Ref frame) - { - fixed (Surface* __dsl_frame = frame) - { - ((ISdl)this).ReleaseCameraFrame(camera, __dsl_frame); - } - } + )(name); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReleaseCameraFrame")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ReleaseCameraFrame(CameraHandle camera, Ref frame) => - DllImport.ReleaseCameraFrame(camera, frame); + public static byte ResetHint([NativeTypeName("const char *")] sbyte* name) => + DllImport.ResetHint(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ReloadGamepadMappings() => - (MaybeBool)(byte)((ISdl)this).ReloadGamepadMappingsRaw(); + MaybeBool ISdl.ResetHint([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)((ISdl)this).ResetHint(__dsl_name); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ReloadGamepadMappings() => DllImport.ReloadGamepadMappings(); + public static MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) => + DllImport.ResetHint(name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ReloadGamepadMappingsRaw() => + void ISdl.ResetHints() => ( - (delegate* unmanaged)( - _slots[627] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[832] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[627] = nativeContext.LoadFunction("SDL_ReloadGamepadMappings", "SDL3") + : _slots[832] = nativeContext.LoadFunction("SDL_ResetHints", "SDL3") ) )(); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ReloadGamepadMappings")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ReloadGamepadMappingsRaw() => DllImport.ReloadGamepadMappingsRaw(); + public static void ResetHints() => DllImport.ResetHints(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => + void ISdl.ResetKeyboard() => ( - (delegate* unmanaged)( - _slots[628] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[833] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[628] = nativeContext.LoadFunction("SDL_RemoveEventWatch", "SDL3") + : _slots[833] = nativeContext.LoadFunction("SDL_ResetKeyboard", "SDL3") ) - )(filter, userdata); - - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => DllImport.RemoveEventWatch(filter, userdata); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveEventWatch([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) - { - fixed (void* __dsl_userdata = userdata) - { - ((ISdl)this).RemoveEventWatch(filter, __dsl_userdata); - } - } + )(); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveEventWatch")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveEventWatch( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => DllImport.RemoveEventWatch(filter, userdata); + public static void ResetKeyboard() => DllImport.ResetKeyboard(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => + void ISdl.ResetLogPriorities() => ( - (delegate* unmanaged)( - _slots[629] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[834] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[629] = nativeContext.LoadFunction("SDL_RemoveHintCallback", "SDL3") + : _slots[834] = nativeContext.LoadFunction("SDL_ResetLogPriorities", "SDL3") ) - )(name, callback, userdata); + )(); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveHintCallback( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - void* userdata - ) => DllImport.RemoveHintCallback(name, callback, userdata); + public static void ResetLogPriorities() => DllImport.ResetLogPriorities(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - fixed (sbyte* __dsl_name = name) - { - ((ISdl)this).RemoveHintCallback(__dsl_name, callback, __dsl_userdata); - } - } + MaybeBool ISdl.RestoreWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).RestoreWindowRaw(window); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveHintCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveHintCallback( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("SDL_HintCallback")] HintCallback callback, - Ref userdata - ) => DllImport.RemoveHintCallback(name, callback, userdata); + public static MaybeBool RestoreWindow(WindowHandle window) => + DllImport.RestoreWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RemovePath([NativeTypeName("const char *")] sbyte* path) => + byte ISdl.RestoreWindowRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[630] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[835] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[630] = nativeContext.LoadFunction("SDL_RemovePath", "SDL3") + : _slots[835] = nativeContext.LoadFunction("SDL_RestoreWindow", "SDL3") ) - )(path); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RemovePath([NativeTypeName("const char *")] sbyte* path) => - DllImport.RemovePath(path); + public static byte RestoreWindowRaw(WindowHandle window) => DllImport.RestoreWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RemovePath([NativeTypeName("const char *")] Ref path) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)((ISdl)this).RemovePath(__dsl_path); - } - } + MaybeBool ISdl.ResumeAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + (MaybeBool)(byte)((ISdl)this).ResumeAudioDeviceRaw(dev); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemovePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RemovePath([NativeTypeName("const char *")] Ref path) => - DllImport.RemovePath(path); + public static MaybeBool ResumeAudioDevice( + [NativeTypeName("SDL_AudioDeviceID")] uint dev + ) => DllImport.ResumeAudioDevice(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => + byte ISdl.ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => ( - (delegate* unmanaged)( - _slots[631] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[836] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[631] = nativeContext.LoadFunction("SDL_RemoveStoragePath", "SDL3") + : _slots[836] = nativeContext.LoadFunction("SDL_ResumeAudioDevice", "SDL3") ) - )(storage, path); + )(dev); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* path - ) => DllImport.RemoveStoragePath(storage, path); + public static byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + DllImport.ResumeAudioDeviceRaw(dev); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) - { - fixed (sbyte* __dsl_path = path) - { - return (MaybeBool)(byte)((ISdl)this).RemoveStoragePath(storage, __dsl_path); - } - } + MaybeBool ISdl.ResumeAudioStreamDevice(AudioStreamHandle stream) => + (MaybeBool)(byte)((ISdl)this).ResumeAudioStreamDeviceRaw(stream); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RemoveStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref path - ) => DllImport.RemoveStoragePath(storage, path); + public static MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => + DllImport.ResumeAudioStreamDevice(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveSurfaceAlternateImages(Surface* surface) => + byte ISdl.ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => ( - (delegate* unmanaged)( - _slots[632] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[837] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[632] = nativeContext.LoadFunction( - "SDL_RemoveSurfaceAlternateImages", + : _slots[837] = nativeContext.LoadFunction( + "SDL_ResumeAudioStreamDevice", "SDL3" ) ) - )(surface); + )(stream); - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveSurfaceAlternateImages(Surface* surface) => - DllImport.RemoveSurfaceAlternateImages(surface); + public static byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => + DllImport.ResumeAudioStreamDeviceRaw(stream); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.RemoveSurfaceAlternateImages(Ref surface) - { - fixed (Surface* __dsl_surface = surface) - { - ((ISdl)this).RemoveSurfaceAlternateImages(__dsl_surface); - } - } + MaybeBool ISdl.ResumeHaptic(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).ResumeHapticRaw(haptic); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveSurfaceAlternateImages")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void RemoveSurfaceAlternateImages(Ref surface) => - DllImport.RemoveSurfaceAlternateImages(surface); + public static MaybeBool ResumeHaptic(HapticHandle haptic) => + DllImport.ResumeHaptic(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => - (MaybeBool)(byte)((ISdl)this).RemoveTimerRaw(id); + byte ISdl.ResumeHapticRaw(HapticHandle haptic) => + ( + (delegate* unmanaged)( + _slots[838] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[838] = nativeContext.LoadFunction("SDL_ResumeHaptic", "SDL3") + ) + )(haptic); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RemoveTimer([NativeTypeName("SDL_TimerID")] uint id) => - DllImport.RemoveTimer(id); + public static byte ResumeHapticRaw(HapticHandle haptic) => DllImport.ResumeHapticRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => + double ISdl.Round(double x) => ( - (delegate* unmanaged)( - _slots[633] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[839] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[633] = nativeContext.LoadFunction("SDL_RemoveTimer", "SDL3") + : _slots[839] = nativeContext.LoadFunction("SDL_round", "SDL3") ) - )(id); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RemoveTimer")] + [NativeFunction("SDL3", EntryPoint = "SDL_round")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RemoveTimerRaw([NativeTypeName("SDL_TimerID")] uint id) => - DllImport.RemoveTimerRaw(id); + public static double Round(double x) => DllImport.Round(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenamePath( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => + float ISdl.Roundf(float x) => ( - (delegate* unmanaged)( - _slots[634] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[840] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[634] = nativeContext.LoadFunction("SDL_RenamePath", "SDL3") + : _slots[840] = nativeContext.LoadFunction("SDL_roundf", "SDL3") ) - )(oldpath, newpath); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_roundf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenamePath( - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => DllImport.RenamePath(oldpath, newpath); + public static float Roundf(float x) => DllImport.Roundf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenamePath( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool)(byte)((ISdl)this).RenamePath(__dsl_oldpath, __dsl_newpath); - } - } + MaybeBool ISdl.RumbleGamepad( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + (MaybeBool) + (byte) + ((ISdl)this).RumbleGamepadRaw( + gamepad, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenamePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenamePath( - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => DllImport.RenamePath(oldpath, newpath); + public static MaybeBool RumbleGamepad( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => DllImport.RumbleGamepad(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath + byte ISdl.RumbleGamepadRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms ) => ( - (delegate* unmanaged)( - _slots[635] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[841] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[635] = nativeContext.LoadFunction("SDL_RenameStoragePath", "SDL3") + : _slots[841] = nativeContext.LoadFunction("SDL_RumbleGamepad", "SDL3") ) - )(storage, oldpath, newpath); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] sbyte* oldpath, - [NativeTypeName("const char *")] sbyte* newpath - ) => DllImport.RenameStoragePath(storage, oldpath, newpath); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) - { - fixed (sbyte* __dsl_newpath = newpath) - fixed (sbyte* __dsl_oldpath = oldpath) - { - return (MaybeBool) - (byte)((ISdl)this).RenameStoragePath(storage, __dsl_oldpath, __dsl_newpath); - } - } + )(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenameStoragePath")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenameStoragePath( - StorageHandle storage, - [NativeTypeName("const char *")] Ref oldpath, - [NativeTypeName("const char *")] Ref newpath - ) => DllImport.RenameStoragePath(storage, oldpath, newpath); + public static byte RumbleGamepadRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + DllImport.RumbleGamepadRaw( + gamepad, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderClear(RendererHandle renderer) => - (MaybeBool)(byte)((ISdl)this).RenderClearRaw(renderer); + MaybeBool ISdl.RumbleGamepadTriggers( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + (MaybeBool) + (byte) + ((ISdl)this).RumbleGamepadTriggersRaw( + gamepad, + left_rumble, + right_rumble, + duration_ms + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderClear(RendererHandle renderer) => - DllImport.RenderClear(renderer); + public static MaybeBool RumbleGamepadTriggers( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => DllImport.RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderClearRaw(RendererHandle renderer) => + byte ISdl.RumbleGamepadTriggersRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => ( - (delegate* unmanaged)( - _slots[636] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[842] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[636] = nativeContext.LoadFunction("SDL_RenderClear", "SDL3") + : _slots[842] = nativeContext.LoadFunction("SDL_RumbleGamepadTriggers", "SDL3") ) - )(renderer); + )(gamepad, left_rumble, right_rumble, duration_ms); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClear")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderClearRaw(RendererHandle renderer) => - DllImport.RenderClearRaw(renderer); + public static byte RumbleGamepadTriggersRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => DllImport.RumbleGamepadTriggersRaw(gamepad, left_rumble, right_rumble, duration_ms); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderClipEnabled(RendererHandle renderer) => - (MaybeBool)(byte)((ISdl)this).RenderClipEnabledRaw(renderer); + MaybeBool ISdl.RumbleJoystick( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + (MaybeBool) + (byte) + ((ISdl)this).RumbleJoystickRaw( + joystick, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderClipEnabled(RendererHandle renderer) => - DllImport.RenderClipEnabled(renderer); + public static MaybeBool RumbleJoystick( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + DllImport.RumbleJoystick( + joystick, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderClipEnabledRaw(RendererHandle renderer) => + byte ISdl.RumbleJoystickRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => ( - (delegate* unmanaged)( - _slots[637] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[843] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[637] = nativeContext.LoadFunction("SDL_RenderClipEnabled", "SDL3") + : _slots[843] = nativeContext.LoadFunction("SDL_RumbleJoystick", "SDL3") ) - )(renderer); + )(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderClipEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderClipEnabledRaw(RendererHandle renderer) => - DllImport.RenderClipEnabledRaw(renderer); + public static byte RumbleJoystickRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort low_frequency_rumble, + [NativeTypeName("Uint16")] ushort high_frequency_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + DllImport.RumbleJoystickRaw( + joystick, + low_frequency_rumble, + high_frequency_rumble, + duration_ms + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - float* x, - float* y + MaybeBool ISdl.RumbleJoystickTriggers( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms ) => - ( - (delegate* unmanaged)( - _slots[638] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[638] = nativeContext.LoadFunction( - "SDL_RenderCoordinatesFromWindow", - "SDL3" - ) - ) - )(renderer, window_x, window_y, x, y); + (MaybeBool) + (byte) + ((ISdl)this).RumbleJoystickTriggersRaw( + joystick, + left_rumble, + right_rumble, + duration_ms + ); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - float* x, - float* y - ) => DllImport.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); - + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - Ref x, - Ref y - ) - { - fixed (float* __dsl_y = y) - fixed (float* __dsl_x = x) - { - return (MaybeBool) - (byte) - ((ISdl)this).RenderCoordinatesFromWindow( - renderer, - window_x, - window_y, - __dsl_x, - __dsl_y - ); - } - } + public static MaybeBool RumbleJoystickTriggers( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => DllImport.RumbleJoystickTriggers(joystick, left_rumble, right_rumble, duration_ms); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.RumbleJoystickTriggersRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => + ( + (delegate* unmanaged)( + _slots[844] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[844] = nativeContext.LoadFunction("SDL_RumbleJoystickTriggers", "SDL3") + ) + )(joystick, left_rumble, right_rumble, duration_ms); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesFromWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderCoordinatesFromWindow( - RendererHandle renderer, - float window_x, - float window_y, - Ref x, - Ref y - ) => DllImport.RenderCoordinatesFromWindow(renderer, window_x, window_y, x, y); + public static byte RumbleJoystickTriggersRaw( + JoystickHandle joystick, + [NativeTypeName("Uint16")] ushort left_rumble, + [NativeTypeName("Uint16")] ushort right_rumble, + [NativeTypeName("Uint32")] uint duration_ms + ) => DllImport.RumbleJoystickTriggersRaw(joystick, left_rumble, right_rumble, duration_ms); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - float* window_x, - float* window_y + int ISdl.RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved ) => ( - (delegate* unmanaged)( - _slots[639] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[845] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[639] = nativeContext.LoadFunction( - "SDL_RenderCoordinatesToWindow", - "SDL3" - ) + : _slots[845] = nativeContext.LoadFunction("SDL_RunApp", "SDL3") ) - )(renderer, x, y, window_x, window_y); + )(argc, argv, mainFunction, reserved); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - float* window_x, - float* window_y - ) => DllImport.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + public static int RunApp( + int argc, + [NativeTypeName("char *[]")] sbyte** argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + void* reserved + ) => DllImport.RunApp(argc, argv, mainFunction, reserved); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - Ref window_x, - Ref window_y + int ISdl.RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved ) { - fixed (float* __dsl_window_y = window_y) - fixed (float* __dsl_window_x = window_x) + fixed (void* __dsl_reserved = reserved) + fixed (sbyte** __dsl_argv = argv) { - return (MaybeBool) - (byte) - ((ISdl)this).RenderCoordinatesToWindow( - renderer, - x, - y, - __dsl_window_x, - __dsl_window_y - ); + return (int)((ISdl)this).RunApp(argc, __dsl_argv, mainFunction, __dsl_reserved); } } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_RunApp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int RunApp( + int argc, + [NativeTypeName("char *[]")] Ref2D argv, + [NativeTypeName("SDL_main_func")] MainFunc mainFunction, + Ref reserved + ) => DllImport.RunApp(argc, argv, mainFunction, reserved); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.RunHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => (MaybeBool)(byte)((ISdl)this).RunHapticEffectRaw(haptic, effect, iterations); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderCoordinatesToWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderCoordinatesToWindow( - RendererHandle renderer, - float x, - float y, - Ref window_x, - Ref window_y - ) => DllImport.RenderCoordinatesToWindow(renderer, x, y, window_x, window_y); + public static MaybeBool RunHapticEffect( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => DllImport.RunHapticEffect(haptic, effect, iterations); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] sbyte* str + byte ISdl.RunHapticEffectRaw( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations ) => ( - (delegate* unmanaged)( - _slots[640] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[846] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[640] = nativeContext.LoadFunction("SDL_RenderDebugText", "SDL3") + : _slots[846] = nativeContext.LoadFunction("SDL_RunHapticEffect", "SDL3") ) - )(renderer, x, y, str); + )(haptic, effect, iterations); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] sbyte* str - ) => DllImport.RenderDebugText(renderer, x, y, str); + public static byte RunHapticEffectRaw( + HapticHandle haptic, + int effect, + [NativeTypeName("Uint32")] uint iterations + ) => DllImport.RunHapticEffectRaw(haptic, effect, iterations); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] Ref str + byte ISdl.SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => + ( + (delegate* unmanaged)( + _slots[847] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[847] = nativeContext.LoadFunction("SDL_SaveBMP", "SDL3") + ) + )(surface, file); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => + DllImport.SaveBMP(surface, file); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SaveBMP( + Ref surface, + [NativeTypeName("const char *")] Ref file ) { - fixed (sbyte* __dsl_str = str) + fixed (sbyte* __dsl_file = file) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)((ISdl)this).RenderDebugText(renderer, x, y, __dsl_str); + return (MaybeBool)(byte)((ISdl)this).SaveBMP(__dsl_surface, __dsl_file); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderDebugText")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderDebugText( - RendererHandle renderer, - float x, - float y, - [NativeTypeName("const char *")] Ref str - ) => DllImport.RenderDebugText(renderer, x, y, str); + public static MaybeBool SaveBMP( + Ref surface, + [NativeTypeName("const char *")] Ref file + ) => DllImport.SaveBMP(surface, file); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect + byte ISdl.SaveBMPIO( + Surface* surface, + IOStreamHandle dst, + [NativeTypeName("bool")] byte closeio ) => ( - (delegate* unmanaged)( - _slots[641] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[848] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[641] = nativeContext.LoadFunction("SDL_RenderFillRect", "SDL3") + : _slots[848] = nativeContext.LoadFunction("SDL_SaveBMP_IO", "SDL3") ) - )(renderer, rect); + )(surface, dst, closeio); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => DllImport.RenderFillRect(renderer, rect); + public static byte SaveBMPIO( + Surface* surface, + IOStreamHandle dst, + [NativeTypeName("bool")] byte closeio + ) => DllImport.SaveBMPIO(surface, dst, closeio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect + MaybeBool ISdl.SaveBMPIO( + Ref surface, + IOStreamHandle dst, + [NativeTypeName("bool")] MaybeBool closeio ) { - fixed (FRect* __dsl_rect = rect) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool)(byte)((ISdl)this).RenderFillRect(renderer, __dsl_rect); + return (MaybeBool)(byte)((ISdl)this).SaveBMPIO(__dsl_surface, dst, (byte)closeio); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderFillRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect - ) => DllImport.RenderFillRect(renderer, rect); + public static MaybeBool SaveBMPIO( + Ref surface, + IOStreamHandle dst, + [NativeTypeName("bool")] MaybeBool closeio + ) => DllImport.SaveBMPIO(surface, dst, closeio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => + double ISdl.Scalbn(double x, int n) => ( - (delegate* unmanaged)( - _slots[642] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[849] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[642] = nativeContext.LoadFunction("SDL_RenderFillRects", "SDL3") + : _slots[849] = nativeContext.LoadFunction("SDL_scalbn", "SDL3") ) - )(renderer, rects, count); + )(x, n); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_scalbn")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => DllImport.RenderFillRects(renderer, rects, count); + public static double Scalbn(double x, int n) => DllImport.Scalbn(x, n); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) - { - fixed (FRect* __dsl_rects = rects) - { - return (MaybeBool) - (byte)((ISdl)this).RenderFillRects(renderer, __dsl_rects, count); - } - } + float ISdl.Scalbnf(float x, int n) => + ( + (delegate* unmanaged)( + _slots[850] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[850] = nativeContext.LoadFunction("SDL_scalbnf", "SDL3") + ) + )(x, n); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderFillRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_scalbnf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderFillRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) => DllImport.RenderFillRects(renderer, rects, count); + public static float Scalbnf(float x, int n) => DllImport.Scalbnf(x, n); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderGeometry( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, - int num_vertices, - [NativeTypeName("const int *")] int* indices, - int num_indices - ) => + Surface* ISdl.ScaleSurface(Surface* surface, int width, int height, ScaleMode scaleMode) => ( - (delegate* unmanaged)( - _slots[643] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[851] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[643] = nativeContext.LoadFunction("SDL_RenderGeometry", "SDL3") + : _slots[851] = nativeContext.LoadFunction("SDL_ScaleSurface", "SDL3") ) - )(renderer, texture, vertices, num_vertices, indices, num_indices); + )(surface, width, height, scaleMode); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderGeometry( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_Vertex *")] Vertex* vertices, - int num_vertices, - [NativeTypeName("const int *")] int* indices, - int num_indices - ) => DllImport.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); + public static Surface* ScaleSurface( + Surface* surface, + int width, + int height, + ScaleMode scaleMode + ) => DllImport.ScaleSurface(surface, width, height, scaleMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderGeometry( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_Vertex *")] Ref vertices, - int num_vertices, - [NativeTypeName("const int *")] Ref indices, - int num_indices - ) + Ptr ISdl.ScaleSurface(Ref surface, int width, int height, ScaleMode scaleMode) { - fixed (int* __dsl_indices = indices) - fixed (Vertex* __dsl_vertices = vertices) - fixed (Texture* __dsl_texture = texture) + fixed (Surface* __dsl_surface = surface) { - return (MaybeBool) - (byte) - ((ISdl)this).RenderGeometry( - renderer, - __dsl_texture, - __dsl_vertices, - num_vertices, - __dsl_indices, - num_indices - ); + return (Surface*)((ISdl)this).ScaleSurface(__dsl_surface, width, height, scaleMode); } } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr ScaleSurface( + Ref surface, + int width, + int height, + ScaleMode scaleMode + ) => DllImport.ScaleSurface(surface, width, height, scaleMode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.ScreenKeyboardShown(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).ScreenKeyboardShownRaw(window); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometry")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderGeometry( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_Vertex *")] Ref vertices, - int num_vertices, - [NativeTypeName("const int *")] Ref indices, - int num_indices - ) => DllImport.RenderGeometry(renderer, texture, vertices, num_vertices, indices, num_indices); + public static MaybeBool ScreenKeyboardShown(WindowHandle window) => + DllImport.ScreenKeyboardShown(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderGeometryRaw( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const float *")] float* xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] FColor* color, - int color_stride, - [NativeTypeName("const float *")] float* uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] void* indices, - int num_indices, - int size_indices - ) => + byte ISdl.ScreenKeyboardShownRaw(WindowHandle window) => ( - (delegate* unmanaged< - RendererHandle, - Texture*, - float*, - int, - FColor*, - int, - float*, - int, - int, - void*, - int, - int, - byte>)( - _slots[644] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[852] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[644] = nativeContext.LoadFunction("SDL_RenderGeometryRaw", "SDL3") + : _slots[852] = nativeContext.LoadFunction("SDL_ScreenKeyboardShown", "SDL3") ) - )( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderGeometryRaw( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const float *")] float* xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] FColor* color, - int color_stride, - [NativeTypeName("const float *")] float* uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] void* indices, - int num_indices, - int size_indices - ) => - DllImport.RenderGeometryRaw( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); + public static byte ScreenKeyboardShownRaw(WindowHandle window) => + DllImport.ScreenKeyboardShownRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderGeometryRaw( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const float *")] Ref xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] Ref color, - int color_stride, - [NativeTypeName("const float *")] Ref uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] Ref indices, - int num_indices, - int size_indices - ) - { - fixed (void* __dsl_indices = indices) - fixed (float* __dsl_uv = uv) - fixed (FColor* __dsl_color = color) - fixed (float* __dsl_xy = xy) - fixed (Texture* __dsl_texture = texture) - { - return (MaybeBool) - (byte) - ((ISdl)this).RenderGeometryRaw( - renderer, - __dsl_texture, - __dsl_xy, - xy_stride, - __dsl_color, - color_stride, - __dsl_uv, - uv_stride, - num_vertices, - __dsl_indices, - num_indices, - size_indices - ); - } - } + MaybeBool ISdl.ScreenSaverEnabled() => + (MaybeBool)(byte)((ISdl)this).ScreenSaverEnabledRaw(); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderGeometryRaw")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderGeometryRaw( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const float *")] Ref xy, - int xy_stride, - [NativeTypeName("const SDL_FColor *")] Ref color, - int color_stride, - [NativeTypeName("const float *")] Ref uv, - int uv_stride, - int num_vertices, - [NativeTypeName("const void *")] Ref indices, - int num_indices, - int size_indices - ) => - DllImport.RenderGeometryRaw( - renderer, - texture, - xy, - xy_stride, - color, - color_stride, - uv, - uv_stride, - num_vertices, - indices, - num_indices, - size_indices - ); - + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderLine( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => (MaybeBool)(byte)((ISdl)this).RenderLineRaw(renderer, x1, y1, x2, y2); + public static MaybeBool ScreenSaverEnabled() => DllImport.ScreenSaverEnabled(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderLine( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => DllImport.RenderLine(renderer, x1, y1, x2, y2); + byte ISdl.ScreenSaverEnabledRaw() => + ( + (delegate* unmanaged)( + _slots[853] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[853] = nativeContext.LoadFunction("SDL_ScreenSaverEnabled", "SDL3") + ) + )(); + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderLineRaw(RendererHandle renderer, float x1, float y1, float x2, float y2) => + public static byte ScreenSaverEnabledRaw() => DllImport.ScreenSaverEnabledRaw(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + long ISdl.SeekIO( + IOStreamHandle context, + [NativeTypeName("Sint64")] long offset, + IOWhence whence + ) => ( - (delegate* unmanaged)( - _slots[645] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[854] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[645] = nativeContext.LoadFunction("SDL_RenderLine", "SDL3") + : _slots[854] = nativeContext.LoadFunction("SDL_SeekIO", "SDL3") ) - )(renderer, x1, y1, x2, y2); + )(context, offset, whence); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLine")] + [return: NativeTypeName("Sint64")] + [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderLineRaw( - RendererHandle renderer, - float x1, - float y1, - float x2, - float y2 - ) => DllImport.RenderLineRaw(renderer, x1, y1, x2, y2); + public static long SeekIO( + IOStreamHandle context, + [NativeTypeName("Sint64")] long offset, + IOWhence whence + ) => DllImport.SeekIO(context, offset, whence); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count + byte ISdl.SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] void* data, + int size ) => ( - (delegate* unmanaged)( - _slots[646] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[855] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[646] = nativeContext.LoadFunction("SDL_RenderLines", "SDL3") + : _slots[855] = nativeContext.LoadFunction("SDL_SendGamepadEffect", "SDL3") ) - )(renderer, points, count); + )(gamepad, data, size); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => DllImport.RenderLines(renderer, points, count); + public static byte SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] void* data, + int size + ) => DllImport.SendGamepadEffect(gamepad, data, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count + MaybeBool ISdl.SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] Ref data, + int size ) { - fixed (FPoint* __dsl_points = points) + fixed (void* __dsl_data = data) { - return (MaybeBool)(byte)((ISdl)this).RenderLines(renderer, __dsl_points, count); + return (MaybeBool)(byte)((ISdl)this).SendGamepadEffect(gamepad, __dsl_data, size); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderLines")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderLines( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) => DllImport.RenderLines(renderer, points, count); + public static MaybeBool SendGamepadEffect( + GamepadHandle gamepad, + [NativeTypeName("const void *")] Ref data, + int size + ) => DllImport.SendGamepadEffect(gamepad, data, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderPoint(RendererHandle renderer, float x, float y) => - (MaybeBool)(byte)((ISdl)this).RenderPointRaw(renderer, x, y); + byte ISdl.SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] void* data, + int size + ) => + ( + (delegate* unmanaged)( + _slots[856] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[856] = nativeContext.LoadFunction("SDL_SendJoystickEffect", "SDL3") + ) + )(joystick, data, size); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderPoint(RendererHandle renderer, float x, float y) => - DllImport.RenderPoint(renderer, x, y); + public static byte SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] void* data, + int size + ) => DllImport.SendJoystickEffect(joystick, data, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderPointRaw(RendererHandle renderer, float x, float y) => - ( - (delegate* unmanaged)( - _slots[647] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[647] = nativeContext.LoadFunction("SDL_RenderPoint", "SDL3") - ) - )(renderer, x, y); + MaybeBool ISdl.SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] Ref data, + int size + ) + { + fixed (void* __dsl_data = data) + { + return (MaybeBool) + (byte)((ISdl)this).SendJoystickEffect(joystick, __dsl_data, size); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoint")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderPointRaw(RendererHandle renderer, float x, float y) => - DllImport.RenderPointRaw(renderer, x, y); + public static MaybeBool SendJoystickEffect( + JoystickHandle joystick, + [NativeTypeName("const void *")] Ref data, + int size + ) => DllImport.SendJoystickEffect(joystick, data, size); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count + byte ISdl.SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] float* data, + int num_values ) => ( - (delegate* unmanaged)( - _slots[648] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[857] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[648] = nativeContext.LoadFunction("SDL_RenderPoints", "SDL3") + : _slots[857] = nativeContext.LoadFunction( + "SDL_SendJoystickVirtualSensorData", + "SDL3" + ) ) - )(renderer, points, count); + )(joystick, type, sensor_timestamp, data, num_values); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] FPoint* points, - int count - ) => DllImport.RenderPoints(renderer, points, count); + public static byte SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] float* data, + int num_values + ) => + DllImport.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count + MaybeBool ISdl.SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] Ref data, + int num_values ) { - fixed (FPoint* __dsl_points = points) + fixed (float* __dsl_data = data) { - return (MaybeBool)(byte)((ISdl)this).RenderPoints(renderer, __dsl_points, count); + return (MaybeBool) + (byte) + ((ISdl)this).SendJoystickVirtualSensorData( + joystick, + type, + sensor_timestamp, + __dsl_data, + num_values + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPoints")] + [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderPoints( - RendererHandle renderer, - [NativeTypeName("const SDL_FPoint *")] Ref points, - int count - ) => DllImport.RenderPoints(renderer, points, count); + public static MaybeBool SendJoystickVirtualSensorData( + JoystickHandle joystick, + SensorType type, + [NativeTypeName("Uint64")] ulong sensor_timestamp, + [NativeTypeName("const float *")] Ref data, + int num_values + ) => + DllImport.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderPresent(RendererHandle renderer) => - (MaybeBool)(byte)((ISdl)this).RenderPresentRaw(renderer); + byte ISdl.SetAppMetadata( + [NativeTypeName("const char *")] sbyte* appname, + [NativeTypeName("const char *")] sbyte* appversion, + [NativeTypeName("const char *")] sbyte* appidentifier + ) => + ( + (delegate* unmanaged)( + _slots[858] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[858] = nativeContext.LoadFunction("SDL_SetAppMetadata", "SDL3") + ) + )(appname, appversion, appidentifier); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderPresent(RendererHandle renderer) => - DllImport.RenderPresent(renderer); + public static byte SetAppMetadata( + [NativeTypeName("const char *")] sbyte* appname, + [NativeTypeName("const char *")] sbyte* appversion, + [NativeTypeName("const char *")] sbyte* appidentifier + ) => DllImport.SetAppMetadata(appname, appversion, appidentifier); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderPresentRaw(RendererHandle renderer) => - ( - (delegate* unmanaged)( - _slots[649] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[649] = nativeContext.LoadFunction("SDL_RenderPresent", "SDL3") - ) - )(renderer); + MaybeBool ISdl.SetAppMetadata( + [NativeTypeName("const char *")] Ref appname, + [NativeTypeName("const char *")] Ref appversion, + [NativeTypeName("const char *")] Ref appidentifier + ) + { + fixed (sbyte* __dsl_appidentifier = appidentifier) + fixed (sbyte* __dsl_appversion = appversion) + fixed (sbyte* __dsl_appname = appname) + { + return (MaybeBool) + (byte) + ((ISdl)this).SetAppMetadata( + __dsl_appname, + __dsl_appversion, + __dsl_appidentifier + ); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderPresent")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderPresentRaw(RendererHandle renderer) => - DllImport.RenderPresentRaw(renderer); + public static MaybeBool SetAppMetadata( + [NativeTypeName("const char *")] Ref appname, + [NativeTypeName("const char *")] Ref appversion, + [NativeTypeName("const char *")] Ref appidentifier + ) => DllImport.SetAppMetadata(appname, appversion, appidentifier); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect + byte ISdl.SetAppMetadataProperty( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value ) => ( - (delegate* unmanaged)( - _slots[650] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[859] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[650] = nativeContext.LoadFunction("SDL_RenderReadPixels", "SDL3") + : _slots[859] = nativeContext.LoadFunction("SDL_SetAppMetadataProperty", "SDL3") ) - )(renderer, rect); + )(name, value); - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => DllImport.RenderReadPixels(renderer, rect); + public static byte SetAppMetadataProperty( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => DllImport.SetAppMetadataProperty(name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect + MaybeBool ISdl.SetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value ) { - fixed (Rect* __dsl_rect = rect) + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - return (Surface*)((ISdl)this).RenderReadPixels(renderer, __dsl_rect); + return (MaybeBool) + (byte)((ISdl)this).SetAppMetadataProperty(__dsl_name, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderReadPixels")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr RenderReadPixels( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => DllImport.RenderReadPixels(renderer, rect); + public static MaybeBool SetAppMetadataProperty( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => DllImport.SetAppMetadataProperty(name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect + void ISdl.SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[651] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[860] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[651] = nativeContext.LoadFunction("SDL_RenderRect", "SDL3") + : _slots[860] = nativeContext.LoadFunction("SDL_SetAssertionHandler", "SDL3") ) - )(renderer, rect); + )(handler, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rect - ) => DllImport.RenderRect(renderer, rect); + public static void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + void* userdata + ) => DllImport.SetAssertionHandler(handler, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect + void ISdl.SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + Ref userdata ) { - fixed (FRect* __dsl_rect = rect) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool)(byte)((ISdl)this).RenderRect(renderer, __dsl_rect); + ((ISdl)this).SetAssertionHandler(handler, __dsl_userdata); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderRect( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rect - ) => DllImport.RenderRect(renderer, rect); + public static void SetAssertionHandler( + [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, + Ref userdata + ) => DllImport.SetAssertionHandler(handler, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => + int ISdl.SetAtomicInt(AtomicInt* a, int v) => ( - (delegate* unmanaged)( - _slots[652] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[861] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[652] = nativeContext.LoadFunction("SDL_RenderRects", "SDL3") + : _slots[861] = nativeContext.LoadFunction("SDL_SetAtomicInt", "SDL3") ) - )(renderer, rects, count); + )(a, v); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] FRect* rects, - int count - ) => DllImport.RenderRects(renderer, rects, count); + public static int SetAtomicInt(AtomicInt* a, int v) => DllImport.SetAtomicInt(a, v); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) + int ISdl.SetAtomicInt(Ref a, int v) { - fixed (FRect* __dsl_rects = rects) + fixed (AtomicInt* __dsl_a = a) { - return (MaybeBool)(byte)((ISdl)this).RenderRects(renderer, __dsl_rects, count); + return (int)((ISdl)this).SetAtomicInt(__dsl_a, v); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderRects")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderRects( - RendererHandle renderer, - [NativeTypeName("const SDL_FRect *")] Ref rects, - int count - ) => DllImport.RenderRects(renderer, rects, count); + public static int SetAtomicInt(Ref a, int v) => DllImport.SetAtomicInt(a, v); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderTexture( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => + void* ISdl.SetAtomicPointer(void** a, void* v) => ( - (delegate* unmanaged)( - _slots[653] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[862] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[653] = nativeContext.LoadFunction("SDL_RenderTexture", "SDL3") + : _slots[862] = nativeContext.LoadFunction("SDL_SetAtomicPointer", "SDL3") ) - )(renderer, texture, srcrect, dstrect); + )(a, v); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderTexture( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => DllImport.RenderTexture(renderer, texture, srcrect, dstrect); + public static void* SetAtomicPointer(void** a, void* v) => DllImport.SetAtomicPointer(a, v); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderTexture( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) + Ptr ISdl.SetAtomicPointer(Ref2D a, Ref v) { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (void* __dsl_v = v) + fixed (void** __dsl_a = a) { - return (MaybeBool) - (byte) - ((ISdl)this).RenderTexture( - renderer, - __dsl_texture, - __dsl_srcrect, - __dsl_dstrect - ); + return (void*)((ISdl)this).SetAtomicPointer(__dsl_a, __dsl_v); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderTexture( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => DllImport.RenderTexture(renderer, texture, srcrect, dstrect); + public static Ptr SetAtomicPointer(Ref2D a, Ref v) => DllImport.SetAtomicPointer(a, v); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderTexture9Grid( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => + uint ISdl.SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => ( - (delegate* unmanaged< - RendererHandle, - Texture*, - FRect*, - float, - float, - float, - float, - float, - FRect*, - byte>)( - _slots[654] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[654] = nativeContext.LoadFunction("SDL_RenderTexture9Grid", "SDL3") - ) - )( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderTexture9Grid( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => - DllImport.RenderTexture9Grid( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); + (delegate* unmanaged)( + _slots[863] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[863] = nativeContext.LoadFunction("SDL_SetAtomicU32", "SDL3") + ) + )(a, v); + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderTexture9Grid( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) + public static uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => + DllImport.SetAtomicU32(a, v); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint ISdl.SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (AtomicU32* __dsl_a = a) { - return (MaybeBool) - (byte) - ((ISdl)this).RenderTexture9Grid( - renderer, - __dsl_texture, - __dsl_srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - __dsl_dstrect - ); + return (uint)((ISdl)this).SetAtomicU32(__dsl_a, v); } } + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) => + DllImport.SetAtomicU32(a, v); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetAudioDeviceGain( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => (MaybeBool)(byte)((ISdl)this).SetAudioDeviceGainRaw(devid, gain); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTexture9Grid")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderTexture9Grid( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float left_width, - float right_width, - float top_height, - float bottom_height, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => - DllImport.RenderTexture9Grid( - renderer, - texture, - srcrect, - left_width, - right_width, - top_height, - bottom_height, - scale, - dstrect - ); + public static MaybeBool SetAudioDeviceGain( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => DllImport.SetAudioDeviceGain(devid, gain); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderTextureRotated( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] FPoint* center, - FlipMode flip + byte ISdl.SetAudioDeviceGainRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid, float gain) => + ( + (delegate* unmanaged)( + _slots[864] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[864] = nativeContext.LoadFunction("SDL_SetAudioDeviceGain", "SDL3") + ) + )(devid, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetAudioDeviceGainRaw( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + float gain + ) => DllImport.SetAudioDeviceGainRaw(devid, gain); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + void* userdata ) => ( - (delegate* unmanaged< - RendererHandle, - Texture*, - FRect*, - FRect*, - double, - FPoint*, - FlipMode, - byte>)( - _slots[655] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[865] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[655] = nativeContext.LoadFunction("SDL_RenderTextureRotated", "SDL3") + : _slots[865] = nativeContext.LoadFunction( + "SDL_SetAudioPostmixCallback", + "SDL3" + ) ) - )(renderer, texture, srcrect, dstrect, angle, center, flip); + )(devid, callback, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderTextureRotated( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] FPoint* center, - FlipMode flip - ) => DllImport.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); + public static byte SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + void* userdata + ) => DllImport.SetAudioPostmixCallback(devid, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderTextureRotated( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] Ref center, - FlipMode flip + MaybeBool ISdl.SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + Ref userdata ) { - fixed (FPoint* __dsl_center = center) - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (void* __dsl_userdata = userdata) { return (MaybeBool) - (byte) - ((ISdl)this).RenderTextureRotated( - renderer, - __dsl_texture, - __dsl_srcrect, - __dsl_dstrect, - angle, - __dsl_center, - flip - ); + (byte)((ISdl)this).SetAudioPostmixCallback(devid, callback, __dsl_userdata); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureRotated")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderTextureRotated( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - [NativeTypeName("const SDL_FRect *")] Ref dstrect, - double angle, - [NativeTypeName("const SDL_FPoint *")] Ref center, - FlipMode flip - ) => DllImport.RenderTextureRotated(renderer, texture, srcrect, dstrect, angle, center, flip); + public static MaybeBool SetAudioPostmixCallback( + [NativeTypeName("SDL_AudioDeviceID")] uint devid, + [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, + Ref userdata + ) => DllImport.SetAudioPostmixCallback(devid, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderTextureTiled( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect + byte ISdl.SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec ) => ( - (delegate* unmanaged)( - _slots[656] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[866] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[656] = nativeContext.LoadFunction("SDL_RenderTextureTiled", "SDL3") + : _slots[866] = nativeContext.LoadFunction("SDL_SetAudioStreamFormat", "SDL3") ) - )(renderer, texture, srcrect, scale, dstrect); + )(stream, src_spec, dst_spec); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderTextureTiled( - RendererHandle renderer, - Texture* texture, - [NativeTypeName("const SDL_FRect *")] FRect* srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] FRect* dstrect - ) => DllImport.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + public static byte SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, + [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec + ) => DllImport.SetAudioStreamFormat(stream, src_spec, dst_spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderTextureTiled( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect + MaybeBool ISdl.SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec ) { - fixed (FRect* __dsl_dstrect = dstrect) - fixed (FRect* __dsl_srcrect = srcrect) - fixed (Texture* __dsl_texture = texture) + fixed (AudioSpec* __dsl_dst_spec = dst_spec) + fixed (AudioSpec* __dsl_src_spec = src_spec) { return (MaybeBool) - (byte) - ((ISdl)this).RenderTextureTiled( - renderer, - __dsl_texture, - __dsl_srcrect, - scale, - __dsl_dstrect - ); + (byte)((ISdl)this).SetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderTextureTiled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderTextureTiled( - RendererHandle renderer, - Ref texture, - [NativeTypeName("const SDL_FRect *")] Ref srcrect, - float scale, - [NativeTypeName("const SDL_FRect *")] Ref dstrect - ) => DllImport.RenderTextureTiled(renderer, texture, srcrect, scale, dstrect); + public static MaybeBool SetAudioStreamFormat( + AudioStreamHandle stream, + [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, + [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec + ) => DllImport.SetAudioStreamFormat(stream, src_spec, dst_spec); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RenderViewportSet(RendererHandle renderer) => - (MaybeBool)(byte)((ISdl)this).RenderViewportSetRaw(renderer); + MaybeBool ISdl.SetAudioStreamFrequencyRatio(AudioStreamHandle stream, float ratio) => + (MaybeBool)(byte)((ISdl)this).SetAudioStreamFrequencyRatioRaw(stream, ratio); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RenderViewportSet(RendererHandle renderer) => - DllImport.RenderViewportSet(renderer); + public static MaybeBool SetAudioStreamFrequencyRatio( + AudioStreamHandle stream, + float ratio + ) => DllImport.SetAudioStreamFrequencyRatio(stream, ratio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RenderViewportSetRaw(RendererHandle renderer) => + byte ISdl.SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => ( - (delegate* unmanaged)( - _slots[657] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[867] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[657] = nativeContext.LoadFunction("SDL_RenderViewportSet", "SDL3") + : _slots[867] = nativeContext.LoadFunction( + "SDL_SetAudioStreamFrequencyRatio", + "SDL3" + ) ) - )(renderer); + )(stream, ratio); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RenderViewportSet")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RenderViewportSetRaw(RendererHandle renderer) => - DllImport.RenderViewportSetRaw(renderer); + public static byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => + DllImport.SetAudioStreamFrequencyRatioRaw(stream, ratio); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertState ISdl.ReportAssertion( - AssertData* data, - [NativeTypeName("const char *")] sbyte* func, - [NativeTypeName("const char *")] sbyte* file, - int line + MaybeBool ISdl.SetAudioStreamGain(AudioStreamHandle stream, float gain) => + (MaybeBool)(byte)((ISdl)this).SetAudioStreamGainRaw(stream, gain); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => + DllImport.SetAudioStreamGain(stream, gain); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => + ( + (delegate* unmanaged)( + _slots[868] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[868] = nativeContext.LoadFunction("SDL_SetAudioStreamGain", "SDL3") + ) + )(stream, gain); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => + DllImport.SetAudioStreamGainRaw(stream, gain); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[658] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[869] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[658] = nativeContext.LoadFunction("SDL_ReportAssertion", "SDL3") + : _slots[869] = nativeContext.LoadFunction( + "SDL_SetAudioStreamGetCallback", + "SDL3" + ) ) - )(data, func, file, line); + )(stream, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertState ReportAssertion( - AssertData* data, - [NativeTypeName("const char *")] sbyte* func, - [NativeTypeName("const char *")] sbyte* file, - int line - ) => DllImport.ReportAssertion(data, func, file, line); + public static byte SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => DllImport.SetAudioStreamGetCallback(stream, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - AssertState ISdl.ReportAssertion( - Ref data, - [NativeTypeName("const char *")] Ref func, - [NativeTypeName("const char *")] Ref file, - int line + MaybeBool ISdl.SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata ) { - fixed (sbyte* __dsl_file = file) - fixed (sbyte* __dsl_func = func) - fixed (AssertData* __dsl_data = data) + fixed (void* __dsl_userdata = userdata) { - return (AssertState) - ((ISdl)this).ReportAssertion(__dsl_data, __dsl_func, __dsl_file, line); + return (MaybeBool) + (byte)((ISdl)this).SetAudioStreamGetCallback(stream, callback, __dsl_userdata); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ReportAssertion")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static AssertState ReportAssertion( - Ref data, - [NativeTypeName("const char *")] Ref func, - [NativeTypeName("const char *")] Ref file, - int line - ) => DllImport.ReportAssertion(data, func, file, line); + public static MaybeBool SetAudioStreamGetCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) => DllImport.SetAudioStreamGetCallback(stream, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ResetAssertionReport() => + byte ISdl.SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => ( - (delegate* unmanaged)( - _slots[659] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[870] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[659] = nativeContext.LoadFunction("SDL_ResetAssertionReport", "SDL3") + : _slots[870] = nativeContext.LoadFunction( + "SDL_SetAudioStreamInputChannelMap", + "SDL3" + ) ) - )(); + )(stream, chmap, count); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetAssertionReport")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ResetAssertionReport() => DllImport.ResetAssertionReport(); + public static byte SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => DllImport.SetAudioStreamInputChannelMap(stream, chmap, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ResetHint([NativeTypeName("const char *")] sbyte* name) => + MaybeBool ISdl.SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) + { + fixed (int* __dsl_chmap = chmap) + { + return (MaybeBool) + (byte)((ISdl)this).SetAudioStreamInputChannelMap(stream, __dsl_chmap, count); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetAudioStreamInputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) => DllImport.SetAudioStreamInputChannelMap(stream, chmap, count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => ( - (delegate* unmanaged)( - _slots[660] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[871] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[660] = nativeContext.LoadFunction("SDL_ResetHint", "SDL3") + : _slots[871] = nativeContext.LoadFunction( + "SDL_SetAudioStreamOutputChannelMap", + "SDL3" + ) ) - )(name); + )(stream, chmap, count); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ResetHint([NativeTypeName("const char *")] sbyte* name) => - DllImport.ResetHint(name); + public static byte SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] int* chmap, + int count + ) => DllImport.SetAudioStreamOutputChannelMap(stream, chmap, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ResetHint([NativeTypeName("const char *")] Ref name) + MaybeBool ISdl.SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) { - fixed (sbyte* __dsl_name = name) + fixed (int* __dsl_chmap = chmap) { - return (MaybeBool)(byte)((ISdl)this).ResetHint(__dsl_name); + return (MaybeBool) + (byte)((ISdl)this).SetAudioStreamOutputChannelMap(stream, __dsl_chmap, count); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ResetHint([NativeTypeName("const char *")] Ref name) => - DllImport.ResetHint(name); + public static MaybeBool SetAudioStreamOutputChannelMap( + AudioStreamHandle stream, + [NativeTypeName("const int *")] Ref chmap, + int count + ) => DllImport.SetAudioStreamOutputChannelMap(stream, chmap, count); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ResetHints() => + byte ISdl.SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => ( - (delegate* unmanaged)( - _slots[661] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[872] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[661] = nativeContext.LoadFunction("SDL_ResetHints", "SDL3") + : _slots[872] = nativeContext.LoadFunction( + "SDL_SetAudioStreamPutCallback", + "SDL3" + ) ) - )(); + )(stream, callback, userdata); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetHints")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ResetHints() => DllImport.ResetHints(); + public static byte SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void* userdata + ) => DllImport.SetAudioStreamPutCallback(stream, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ResetKeyboard() => - ( - (delegate* unmanaged)( - _slots[662] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[662] = nativeContext.LoadFunction("SDL_ResetKeyboard", "SDL3") - ) - )(); + MaybeBool ISdl.SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) + { + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte)((ISdl)this).SetAudioStreamPutCallback(stream, callback, __dsl_userdata); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_ResetKeyboard")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ResetKeyboard() => DllImport.ResetKeyboard(); + public static MaybeBool SetAudioStreamPutCallback( + AudioStreamHandle stream, + [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + Ref userdata + ) => DllImport.SetAudioStreamPutCallback(stream, callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ResetLogPriorities() => + byte ISdl.SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte value + ) => ( - (delegate* unmanaged)( - _slots[663] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[873] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[663] = nativeContext.LoadFunction("SDL_ResetLogPriorities", "SDL3") + : _slots[873] = nativeContext.LoadFunction("SDL_SetBooleanProperty", "SDL3") ) - )(); + )(props, name, value); - [NativeFunction("SDL3", EntryPoint = "SDL_ResetLogPriorities")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ResetLogPriorities() => DllImport.ResetLogPriorities(); + public static byte SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("bool")] byte value + ) => DllImport.SetBooleanProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RestoreWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).RestoreWindowRaw(window); + MaybeBool ISdl.SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool value + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)((ISdl)this).SetBooleanProperty(props, __dsl_name, (byte)value); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RestoreWindow(WindowHandle window) => - DllImport.RestoreWindow(window); + public static MaybeBool SetBooleanProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("bool")] MaybeBool value + ) => DllImport.SetBooleanProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RestoreWindowRaw(WindowHandle window) => + byte ISdl.SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + void* userdata, + [NativeTypeName("const char **")] sbyte** mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => ( - (delegate* unmanaged)( - _slots[664] is not null and var loadedFnPtr + (delegate* unmanaged< + ClipboardDataCallback, + ClipboardCleanupCallback, + void*, + sbyte**, + nuint, + byte>)( + _slots[874] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[664] = nativeContext.LoadFunction("SDL_RestoreWindow", "SDL3") + : _slots[874] = nativeContext.LoadFunction("SDL_SetClipboardData", "SDL3") ) - )(window); + )(callback, cleanup, userdata, mime_types, num_mime_types); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RestoreWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RestoreWindowRaw(WindowHandle window) => DllImport.RestoreWindowRaw(window); + public static byte SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + void* userdata, + [NativeTypeName("const char **")] sbyte** mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => DllImport.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ResumeAudioDevice([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - (MaybeBool)(byte)((ISdl)this).ResumeAudioDeviceRaw(dev); + MaybeBool ISdl.SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + Ref userdata, + [NativeTypeName("const char **")] Ref2D mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) + { + fixed (sbyte** __dsl_mime_types = mime_types) + fixed (void* __dsl_userdata = userdata) + { + return (MaybeBool) + (byte) + ((ISdl)this).SetClipboardData( + callback, + cleanup, + __dsl_userdata, + __dsl_mime_types, + num_mime_types + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ResumeAudioDevice( - [NativeTypeName("SDL_AudioDeviceID")] uint dev - ) => DllImport.ResumeAudioDevice(dev); + public static MaybeBool SetClipboardData( + [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, + [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, + Ref userdata, + [NativeTypeName("const char **")] Ref2D mime_types, + [NativeTypeName("size_t")] nuint num_mime_types + ) => DllImport.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => + byte ISdl.SetClipboardText([NativeTypeName("const char *")] sbyte* text) => ( - (delegate* unmanaged)( - _slots[665] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[875] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[665] = nativeContext.LoadFunction("SDL_ResumeAudioDevice", "SDL3") + : _slots[875] = nativeContext.LoadFunction("SDL_SetClipboardText", "SDL3") ) - )(dev); + )(text); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ResumeAudioDeviceRaw([NativeTypeName("SDL_AudioDeviceID")] uint dev) => - DllImport.ResumeAudioDeviceRaw(dev); + public static byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => + DllImport.SetClipboardText(text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ResumeAudioStreamDevice(AudioStreamHandle stream) => - (MaybeBool)(byte)((ISdl)this).ResumeAudioStreamDeviceRaw(stream); + MaybeBool ISdl.SetClipboardText([NativeTypeName("const char *")] Ref text) + { + fixed (sbyte* __dsl_text = text) + { + return (MaybeBool)(byte)((ISdl)this).SetClipboardText(__dsl_text); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ResumeAudioStreamDevice(AudioStreamHandle stream) => - DllImport.ResumeAudioStreamDevice(stream); + public static MaybeBool SetClipboardText( + [NativeTypeName("const char *")] Ref text + ) => DllImport.SetClipboardText(text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => + MaybeBool ISdl.SetCurrentThreadPriority(ThreadPriority priority) => + (MaybeBool)(byte)((ISdl)this).SetCurrentThreadPriorityRaw(priority); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => + DllImport.SetCurrentThreadPriority(priority); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetCurrentThreadPriorityRaw(ThreadPriority priority) => ( - (delegate* unmanaged)( - _slots[666] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[876] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[666] = nativeContext.LoadFunction( - "SDL_ResumeAudioStreamDevice", + : _slots[876] = nativeContext.LoadFunction( + "SDL_SetCurrentThreadPriority", "SDL3" ) ) - )(stream); + )(priority); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeAudioStreamDevice")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ResumeAudioStreamDeviceRaw(AudioStreamHandle stream) => - DllImport.ResumeAudioStreamDeviceRaw(stream); + public static byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => + DllImport.SetCurrentThreadPriorityRaw(priority); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ResumeHaptic(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).ResumeHapticRaw(haptic); + MaybeBool ISdl.SetCursor(CursorHandle cursor) => + (MaybeBool)(byte)((ISdl)this).SetCursorRaw(cursor); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ResumeHaptic(HapticHandle haptic) => - DllImport.ResumeHaptic(haptic); + public static MaybeBool SetCursor(CursorHandle cursor) => DllImport.SetCursor(cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ResumeHapticRaw(HapticHandle haptic) => + byte ISdl.SetCursorRaw(CursorHandle cursor) => ( - (delegate* unmanaged)( - _slots[667] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[877] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[667] = nativeContext.LoadFunction("SDL_ResumeHaptic", "SDL3") + : _slots[877] = nativeContext.LoadFunction("SDL_SetCursor", "SDL3") ) - )(haptic); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ResumeHaptic")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ResumeHapticRaw(HapticHandle haptic) => DllImport.ResumeHapticRaw(haptic); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RumbleGamepad( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - (MaybeBool) - (byte) - ((ISdl)this).RumbleGamepadRaw( - gamepad, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + )(cursor); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RumbleGamepad( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => DllImport.RumbleGamepad(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); + public static byte SetCursorRaw(CursorHandle cursor) => DllImport.SetCursorRaw(cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RumbleGamepadRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms + int ISdl.SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite ) => ( - (delegate* unmanaged)( - _slots[668] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[878] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[668] = nativeContext.LoadFunction("SDL_RumbleGamepad", "SDL3") + : _slots[878] = nativeContext.LoadFunction("SDL_setenv_unsafe", "SDL3") ) - )(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); + )(name, value, overwrite); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepad")] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RumbleGamepadRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - DllImport.RumbleGamepadRaw( - gamepad, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static int SetenvUnsafe( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + int overwrite + ) => DllImport.SetenvUnsafe(name, value, overwrite); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RumbleGamepadTriggers( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - (MaybeBool) - (byte) - ((ISdl)this).RumbleGamepadTriggersRaw( - gamepad, - left_rumble, - right_rumble, - duration_ms - ); + int ISdl.SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (int)((ISdl)this).SetenvUnsafe(__dsl_name, __dsl_value, overwrite); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_setenv_unsafe")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RumbleGamepadTriggers( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => DllImport.RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms); + public static int SetenvUnsafe( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + int overwrite + ) => DllImport.SetenvUnsafe(name, value, overwrite); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RumbleGamepadTriggersRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms + byte ISdl.SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite ) => ( - (delegate* unmanaged)( - _slots[669] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[879] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[669] = nativeContext.LoadFunction("SDL_RumbleGamepadTriggers", "SDL3") + : _slots[879] = nativeContext.LoadFunction("SDL_SetEnvironmentVariable", "SDL3") ) - )(gamepad, left_rumble, right_rumble, duration_ms); + )(env, name, value, overwrite); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleGamepadTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RumbleGamepadTriggersRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => DllImport.RumbleGamepadTriggersRaw(gamepad, left_rumble, right_rumble, duration_ms); + public static byte SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + [NativeTypeName("bool")] byte overwrite + ) => DllImport.SetEnvironmentVariable(env, name, value, overwrite); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RumbleJoystick( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - (MaybeBool) - (byte) - ((ISdl)this).RumbleJoystickRaw( - joystick, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + MaybeBool ISdl.SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte) + ((ISdl)this).SetEnvironmentVariable( + env, + __dsl_name, + __dsl_value, + (byte)overwrite + ); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEnvironmentVariable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RumbleJoystick( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - DllImport.RumbleJoystick( - joystick, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static MaybeBool SetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + [NativeTypeName("bool")] MaybeBool overwrite + ) => DllImport.SetEnvironmentVariable(env, name, value, overwrite); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RumbleJoystickRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms + byte ISdl.SetErrorV( + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap ) => ( - (delegate* unmanaged)( - _slots[670] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[880] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[670] = nativeContext.LoadFunction("SDL_RumbleJoystick", "SDL3") + : _slots[880] = nativeContext.LoadFunction("SDL_SetErrorV", "SDL3") ) - )(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); + )(fmt, ap); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystick")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RumbleJoystickRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort low_frequency_rumble, - [NativeTypeName("Uint16")] ushort high_frequency_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - DllImport.RumbleJoystickRaw( - joystick, - low_frequency_rumble, - high_frequency_rumble, - duration_ms - ); + public static byte SetErrorV( + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.SetErrorV(fmt, ap); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RumbleJoystickTriggers( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => - (MaybeBool) - (byte) - ((ISdl)this).RumbleJoystickTriggersRaw( - joystick, - left_rumble, - right_rumble, - duration_ms - ); + MaybeBool ISdl.SetErrorV( + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + { + return (MaybeBool)(byte)((ISdl)this).SetErrorV(__dsl_fmt, __dsl_ap); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RumbleJoystickTriggers( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => DllImport.RumbleJoystickTriggers(joystick, left_rumble, right_rumble, duration_ms); + public static MaybeBool SetErrorV( + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.SetErrorV(fmt, ap); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RumbleJoystickTriggersRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms + void ISdl.SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] byte enabled ) => ( - (delegate* unmanaged)( - _slots[671] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[881] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[671] = nativeContext.LoadFunction("SDL_RumbleJoystickTriggers", "SDL3") + : _slots[881] = nativeContext.LoadFunction("SDL_SetEventEnabled", "SDL3") ) - )(joystick, left_rumble, right_rumble, duration_ms); + )(type, enabled); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RumbleJoystickTriggers")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RumbleJoystickTriggersRaw( - JoystickHandle joystick, - [NativeTypeName("Uint16")] ushort left_rumble, - [NativeTypeName("Uint16")] ushort right_rumble, - [NativeTypeName("Uint32")] uint duration_ms - ) => DllImport.RumbleJoystickTriggersRaw(joystick, left_rumble, right_rumble, duration_ms); + public static void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] byte enabled + ) => DllImport.SetEventEnabled(type, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.RunHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => (MaybeBool)(byte)((ISdl)this).RunHapticEffectRaw(haptic, effect, iterations); + void ISdl.SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] MaybeBool enabled + ) => ((ISdl)this).SetEventEnabled(type, (byte)enabled); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool RunHapticEffect( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => DllImport.RunHapticEffect(haptic, effect, iterations); + public static void SetEventEnabled( + [NativeTypeName("Uint32")] uint type, + [NativeTypeName("bool")] MaybeBool enabled + ) => DllImport.SetEventEnabled(type, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.RunHapticEffectRaw( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations + void ISdl.SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[672] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[882] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[672] = nativeContext.LoadFunction("SDL_RunHapticEffect", "SDL3") + : _slots[882] = nativeContext.LoadFunction("SDL_SetEventFilter", "SDL3") ) - )(haptic, effect, iterations); + )(filter, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_RunHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte RunHapticEffectRaw( - HapticHandle haptic, - int effect, - [NativeTypeName("Uint32")] uint iterations - ) => DllImport.RunHapticEffectRaw(haptic, effect, iterations); + public static void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + void* userdata + ) => DllImport.SetEventFilter(filter, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => + void ISdl.SetEventFilter([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) + { + fixed (void* __dsl_userdata = userdata) + { + ((ISdl)this).SetEventFilter(filter, __dsl_userdata); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void SetEventFilter( + [NativeTypeName("SDL_EventFilter")] EventFilter filter, + Ref userdata + ) => DllImport.SetEventFilter(filter, userdata); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float value + ) => ( - (delegate* unmanaged)( - _slots[673] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[883] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[673] = nativeContext.LoadFunction("SDL_SaveBMP", "SDL3") + : _slots[883] = nativeContext.LoadFunction("SDL_SetFloatProperty", "SDL3") ) - )(surface, file); + )(props, name, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SaveBMP(Surface* surface, [NativeTypeName("const char *")] sbyte* file) => - DllImport.SaveBMP(surface, file); + public static byte SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + float value + ) => DllImport.SetFloatProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SaveBMP( - Ref surface, - [NativeTypeName("const char *")] Ref file + MaybeBool ISdl.SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float value ) { - fixed (sbyte* __dsl_file = file) - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).SaveBMP(__dsl_surface, __dsl_file); + return (MaybeBool)(byte)((ISdl)this).SetFloatProperty(props, __dsl_name, value); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SaveBMP( - Ref surface, - [NativeTypeName("const char *")] Ref file - ) => DllImport.SaveBMP(surface, file); + public static MaybeBool SetFloatProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + float value + ) => DllImport.SetFloatProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SaveBMPIO( - Surface* surface, - IOStreamHandle dst, - [NativeTypeName("bool")] byte closeio - ) => + void ISdl.SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => ( - (delegate* unmanaged)( - _slots[674] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[884] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[674] = nativeContext.LoadFunction("SDL_SaveBMP_IO", "SDL3") + : _slots[884] = nativeContext.LoadFunction( + "SDL_SetGamepadEventsEnabled", + "SDL3" + ) ) - )(surface, dst, closeio); + )(enabled); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SaveBMPIO( - Surface* surface, - IOStreamHandle dst, - [NativeTypeName("bool")] byte closeio - ) => DllImport.SaveBMPIO(surface, dst, closeio); + public static void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => + DllImport.SetGamepadEventsEnabled(enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SaveBMPIO( - Ref surface, - IOStreamHandle dst, - [NativeTypeName("bool")] MaybeBool closeio - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).SaveBMPIO(__dsl_surface, dst, (byte)closeio); - } - } + void ISdl.SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + ((ISdl)this).SetGamepadEventsEnabled((byte)enabled); + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + DllImport.SetGamepadEventsEnabled(enabled); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetGamepadLED( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => (MaybeBool)(byte)((ISdl)this).SetGamepadLEDRaw(gamepad, red, green, blue); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SaveBMP_IO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SaveBMPIO( - Ref surface, - IOStreamHandle dst, - [NativeTypeName("bool")] MaybeBool closeio - ) => DllImport.SaveBMPIO(surface, dst, closeio); + public static MaybeBool SetGamepadLED( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => DllImport.SetGamepadLED(gamepad, red, green, blue); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Surface* ISdl.ScaleSurface(Surface* surface, int width, int height, ScaleMode scaleMode) => + byte ISdl.SetGamepadLEDRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => ( - (delegate* unmanaged)( - _slots[675] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[885] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[675] = nativeContext.LoadFunction("SDL_ScaleSurface", "SDL3") + : _slots[885] = nativeContext.LoadFunction("SDL_SetGamepadLED", "SDL3") ) - )(surface, width, height, scaleMode); + )(gamepad, red, green, blue); - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Surface* ScaleSurface( - Surface* surface, - int width, - int height, - ScaleMode scaleMode - ) => DllImport.ScaleSurface(surface, width, height, scaleMode); + public static byte SetGamepadLEDRaw( + GamepadHandle gamepad, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => DllImport.SetGamepadLEDRaw(gamepad, red, green, blue); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.ScaleSurface(Ref surface, int width, int height, ScaleMode scaleMode) + byte ISdl.SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] sbyte* mapping + ) => + ( + (delegate* unmanaged)( + _slots[886] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[886] = nativeContext.LoadFunction("SDL_SetGamepadMapping", "SDL3") + ) + )(instance_id, mapping); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] sbyte* mapping + ) => DllImport.SetGamepadMapping(instance_id, mapping); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] Ref mapping + ) { - fixed (Surface* __dsl_surface = surface) + fixed (sbyte* __dsl_mapping = mapping) { - return (Surface*)((ISdl)this).ScaleSurface(__dsl_surface, width, height, scaleMode); + return (MaybeBool) + (byte)((ISdl)this).SetGamepadMapping(instance_id, __dsl_mapping); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScaleSurface")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr ScaleSurface( - Ref surface, - int width, - int height, - ScaleMode scaleMode - ) => DllImport.ScaleSurface(surface, width, height, scaleMode); + public static MaybeBool SetGamepadMapping( + [NativeTypeName("SDL_JoystickID")] uint instance_id, + [NativeTypeName("const char *")] Ref mapping + ) => DllImport.SetGamepadMapping(instance_id, mapping); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ScreenKeyboardShown(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).ScreenKeyboardShownRaw(window); + MaybeBool ISdl.SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => + (MaybeBool)(byte)((ISdl)this).SetGamepadPlayerIndexRaw(gamepad, player_index); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ScreenKeyboardShown(WindowHandle window) => - DllImport.ScreenKeyboardShown(window); + public static MaybeBool SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => + DllImport.SetGamepadPlayerIndex(gamepad, player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ScreenKeyboardShownRaw(WindowHandle window) => + byte ISdl.SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => ( - (delegate* unmanaged)( - _slots[676] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[887] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[676] = nativeContext.LoadFunction("SDL_ScreenKeyboardShown", "SDL3") + : _slots[887] = nativeContext.LoadFunction("SDL_SetGamepadPlayerIndex", "SDL3") ) - )(window); + )(gamepad, player_index); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenKeyboardShown")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ScreenKeyboardShownRaw(WindowHandle window) => - DllImport.ScreenKeyboardShownRaw(window); + public static byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => + DllImport.SetGamepadPlayerIndexRaw(gamepad, player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ScreenSaverEnabled() => - (MaybeBool)(byte)((ISdl)this).ScreenSaverEnabledRaw(); + byte ISdl.SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] byte enabled + ) => + ( + (delegate* unmanaged)( + _slots[888] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[888] = nativeContext.LoadFunction( + "SDL_SetGamepadSensorEnabled", + "SDL3" + ) + ) + )(gamepad, type, enabled); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ScreenSaverEnabled() => DllImport.ScreenSaverEnabled(); + public static byte SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] byte enabled + ) => DllImport.SetGamepadSensorEnabled(gamepad, type, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ScreenSaverEnabledRaw() => - ( - (delegate* unmanaged)( - _slots[677] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[677] = nativeContext.LoadFunction("SDL_ScreenSaverEnabled", "SDL3") - ) - )(); + MaybeBool ISdl.SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] MaybeBool enabled + ) => (MaybeBool)(byte)((ISdl)this).SetGamepadSensorEnabled(gamepad, type, (byte)enabled); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ScreenSaverEnabled")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ScreenSaverEnabledRaw() => DllImport.ScreenSaverEnabledRaw(); + public static MaybeBool SetGamepadSensorEnabled( + GamepadHandle gamepad, + SensorType type, + [NativeTypeName("bool")] MaybeBool enabled + ) => DllImport.SetGamepadSensorEnabled(gamepad, type, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - long ISdl.SeekIO( - IOStreamHandle context, - [NativeTypeName("Sint64")] long offset, - IOWhence whence - ) => + void ISdl.SetGPUBlendConstants(GPURenderPassHandle render_pass, FColor blend_constants) => ( - (delegate* unmanaged)( - _slots[678] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[889] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[678] = nativeContext.LoadFunction("SDL_SeekIO", "SDL3") + : _slots[889] = nativeContext.LoadFunction("SDL_SetGPUBlendConstants", "SDL3") ) - )(context, offset, whence); + )(render_pass, blend_constants); - [return: NativeTypeName("Sint64")] - [NativeFunction("SDL3", EntryPoint = "SDL_SeekIO")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBlendConstants")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static long SeekIO( - IOStreamHandle context, - [NativeTypeName("Sint64")] long offset, - IOWhence whence - ) => DllImport.SeekIO(context, offset, whence); + public static void SetGPUBlendConstants( + GPURenderPassHandle render_pass, + FColor blend_constants + ) => DllImport.SetGPUBlendConstants(render_pass, blend_constants); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] void* data, - int size + void ISdl.SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text ) => ( - (delegate* unmanaged)( - _slots[679] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[890] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[679] = nativeContext.LoadFunction("SDL_SendGamepadEffect", "SDL3") + : _slots[890] = nativeContext.LoadFunction("SDL_SetGPUBufferName", "SDL3") ) - )(gamepad, data, size); + )(device, buffer, text); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] void* data, - int size - ) => DllImport.SendGamepadEffect(gamepad, data, size); + public static void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] sbyte* text + ) => DllImport.SetGPUBufferName(device, buffer, text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] Ref data, - int size + void ISdl.SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text ) { - fixed (void* __dsl_data = data) + fixed (sbyte* __dsl_text = text) { - return (MaybeBool)(byte)((ISdl)this).SendGamepadEffect(gamepad, __dsl_data, size); + ((ISdl)this).SetGPUBufferName(device, buffer, __dsl_text); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendGamepadEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUBufferName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SendGamepadEffect( - GamepadHandle gamepad, - [NativeTypeName("const void *")] Ref data, - int size - ) => DllImport.SendGamepadEffect(gamepad, data, size); + public static void SetGPUBufferName( + GPUDeviceHandle device, + GPUBufferHandle buffer, + [NativeTypeName("const char *")] Ref text + ) => DllImport.SetGPUBufferName(device, buffer, text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] void* data, - int size + void ISdl.SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor ) => ( - (delegate* unmanaged)( - _slots[680] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[891] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[680] = nativeContext.LoadFunction("SDL_SendJoystickEffect", "SDL3") + : _slots[891] = nativeContext.LoadFunction("SDL_SetGPUScissor", "SDL3") ) - )(joystick, data, size); + )(render_pass, scissor); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] void* data, - int size - ) => DllImport.SendJoystickEffect(joystick, data, size); + public static void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Rect* scissor + ) => DllImport.SetGPUScissor(render_pass, scissor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] Ref data, - int size + void ISdl.SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor ) { - fixed (void* __dsl_data = data) + fixed (Rect* __dsl_scissor = scissor) { - return (MaybeBool) - (byte)((ISdl)this).SendJoystickEffect(joystick, __dsl_data, size); + ((ISdl)this).SetGPUScissor(render_pass, __dsl_scissor); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUScissor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SendJoystickEffect( - JoystickHandle joystick, - [NativeTypeName("const void *")] Ref data, - int size - ) => DllImport.SendJoystickEffect(joystick, data, size); + public static void SetGPUScissor( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_Rect *")] Ref scissor + ) => DllImport.SetGPUScissor(render_pass, scissor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] float* data, - int num_values + void ISdl.SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference ) => ( - (delegate* unmanaged)( - _slots[681] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[892] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[681] = nativeContext.LoadFunction( - "SDL_SendJoystickVirtualSensorData", - "SDL3" - ) + : _slots[892] = nativeContext.LoadFunction("SDL_SetGPUStencilReference", "SDL3") ) - )(joystick, type, sensor_timestamp, data, num_values); + )(render_pass, reference); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUStencilReference")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] float* data, - int num_values - ) => - DllImport.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); + public static void SetGPUStencilReference( + GPURenderPassHandle render_pass, + [NativeTypeName("Uint8")] byte reference + ) => DllImport.SetGPUStencilReference(render_pass, reference); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] Ref data, - int num_values - ) - { - fixed (float* __dsl_data = data) - { - return (MaybeBool) - (byte) - ((ISdl)this).SendJoystickVirtualSensorData( - joystick, - type, - sensor_timestamp, - __dsl_data, - num_values - ); - } - } + MaybeBool ISdl.SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => + (MaybeBool) + (byte) + ((ISdl)this).SetGPUSwapchainParametersRaw( + device, + window, + swapchain_composition, + present_mode + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SendJoystickVirtualSensorData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SendJoystickVirtualSensorData( - JoystickHandle joystick, - SensorType type, - [NativeTypeName("Uint64")] ulong sensor_timestamp, - [NativeTypeName("const float *")] Ref data, - int num_values - ) => - DllImport.SendJoystickVirtualSensorData(joystick, type, sensor_timestamp, data, num_values); + public static MaybeBool SetGPUSwapchainParameters( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => DllImport.SetGPUSwapchainParameters(device, window, swapchain_composition, present_mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAppMetadata( - [NativeTypeName("const char *")] sbyte* appname, - [NativeTypeName("const char *")] sbyte* appversion, - [NativeTypeName("const char *")] sbyte* appidentifier + byte ISdl.SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode ) => ( - (delegate* unmanaged)( - _slots[682] is not null and var loadedFnPtr + (delegate* unmanaged< + GPUDeviceHandle, + WindowHandle, + GPUSwapchainComposition, + GPUPresentMode, + byte>)( + _slots[893] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[682] = nativeContext.LoadFunction("SDL_SetAppMetadata", "SDL3") + : _slots[893] = nativeContext.LoadFunction( + "SDL_SetGPUSwapchainParameters", + "SDL3" + ) ) - )(appname, appversion, appidentifier); + )(device, window, swapchain_composition, present_mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUSwapchainParameters")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAppMetadata( - [NativeTypeName("const char *")] sbyte* appname, - [NativeTypeName("const char *")] sbyte* appversion, - [NativeTypeName("const char *")] sbyte* appidentifier - ) => DllImport.SetAppMetadata(appname, appversion, appidentifier); + public static byte SetGPUSwapchainParametersRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition, + GPUPresentMode present_mode + ) => + DllImport.SetGPUSwapchainParametersRaw(device, window, swapchain_composition, present_mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAppMetadata( - [NativeTypeName("const char *")] Ref appname, - [NativeTypeName("const char *")] Ref appversion, - [NativeTypeName("const char *")] Ref appidentifier + void ISdl.SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ) => + ( + (delegate* unmanaged)( + _slots[894] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[894] = nativeContext.LoadFunction("SDL_SetGPUTextureName", "SDL3") + ) + )(device, texture, text); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] sbyte* text + ) => DllImport.SetGPUTextureName(device, texture, text); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text ) { - fixed (sbyte* __dsl_appidentifier = appidentifier) - fixed (sbyte* __dsl_appversion = appversion) - fixed (sbyte* __dsl_appname = appname) + fixed (sbyte* __dsl_text = text) { - return (MaybeBool) - (byte) - ((ISdl)this).SetAppMetadata( - __dsl_appname, - __dsl_appversion, - __dsl_appidentifier - ); + ((ISdl)this).SetGPUTextureName(device, texture, __dsl_text); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadata")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUTextureName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAppMetadata( - [NativeTypeName("const char *")] Ref appname, - [NativeTypeName("const char *")] Ref appversion, - [NativeTypeName("const char *")] Ref appidentifier - ) => DllImport.SetAppMetadata(appname, appversion, appidentifier); + public static void SetGPUTextureName( + GPUDeviceHandle device, + GPUTextureHandle texture, + [NativeTypeName("const char *")] Ref text + ) => DllImport.SetGPUTextureName(device, texture, text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAppMetadataProperty( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value + void ISdl.SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport ) => ( - (delegate* unmanaged)( - _slots[683] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[895] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[683] = nativeContext.LoadFunction("SDL_SetAppMetadataProperty", "SDL3") + : _slots[895] = nativeContext.LoadFunction("SDL_SetGPUViewport", "SDL3") ) - )(name, value); + )(render_pass, viewport); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAppMetadataProperty( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => DllImport.SetAppMetadataProperty(name, value); + public static void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] GPUViewport* viewport + ) => DllImport.SetGPUViewport(render_pass, viewport); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value + void ISdl.SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (GPUViewport* __dsl_viewport = viewport) { - return (MaybeBool) - (byte)((ISdl)this).SetAppMetadataProperty(__dsl_name, __dsl_value); + ((ISdl)this).SetGPUViewport(render_pass, __dsl_viewport); } } + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetGPUViewport")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void SetGPUViewport( + GPURenderPassHandle render_pass, + [NativeTypeName("const SDL_GPUViewport *")] Ref viewport + ) => DllImport.SetGPUViewport(render_pass, viewport); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetHapticAutocenter(HapticHandle haptic, int autocenter) => + (MaybeBool)(byte)((ISdl)this).SetHapticAutocenterRaw(haptic, autocenter); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAppMetadataProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAppMetadataProperty( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => DllImport.SetAppMetadataProperty(name, value); + public static MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => + DllImport.SetHapticAutocenter(haptic, autocenter); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - void* userdata - ) => + byte ISdl.SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => ( - (delegate* unmanaged)( - _slots[684] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[896] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[684] = nativeContext.LoadFunction("SDL_SetAssertionHandler", "SDL3") + : _slots[896] = nativeContext.LoadFunction("SDL_SetHapticAutocenter", "SDL3") ) - )(handler, userdata); + )(haptic, autocenter); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - void* userdata - ) => DllImport.SetAssertionHandler(handler, userdata); + public static byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => + DllImport.SetHapticAutocenterRaw(haptic, autocenter); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - ((ISdl)this).SetAssertionHandler(handler, __dsl_userdata); - } - } + MaybeBool ISdl.SetHapticGain(HapticHandle haptic, int gain) => + (MaybeBool)(byte)((ISdl)this).SetHapticGainRaw(haptic, gain); + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAssertionHandler")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetAssertionHandler( - [NativeTypeName("SDL_AssertionHandler")] AssertionHandler handler, - Ref userdata - ) => DllImport.SetAssertionHandler(handler, userdata); + public static MaybeBool SetHapticGain(HapticHandle haptic, int gain) => + DllImport.SetHapticGain(haptic, gain); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.SetAtomicInt(AtomicInt* a, int v) => + byte ISdl.SetHapticGainRaw(HapticHandle haptic, int gain) => ( - (delegate* unmanaged)( - _slots[685] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[897] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[685] = nativeContext.LoadFunction("SDL_SetAtomicInt", "SDL3") + : _slots[897] = nativeContext.LoadFunction("SDL_SetHapticGain", "SDL3") ) - )(a, v); + )(haptic, gain); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int SetAtomicInt(AtomicInt* a, int v) => DllImport.SetAtomicInt(a, v); + public static byte SetHapticGainRaw(HapticHandle haptic, int gain) => + DllImport.SetHapticGainRaw(haptic, gain); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetHint( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => + ( + (delegate* unmanaged)( + _slots[898] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[898] = nativeContext.LoadFunction("SDL_SetHint", "SDL3") + ) + )(name, value); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetHint( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => DllImport.SetHint(name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - int ISdl.SetAtomicInt(Ref a, int v) + MaybeBool ISdl.SetHint( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) { - fixed (AtomicInt* __dsl_a = a) + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - return (int)((ISdl)this).SetAtomicInt(__dsl_a, v); + return (MaybeBool)(byte)((ISdl)this).SetHint(__dsl_name, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicInt")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static int SetAtomicInt(Ref a, int v) => DllImport.SetAtomicInt(a, v); + public static MaybeBool SetHint( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => DllImport.SetHint(name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void* ISdl.SetAtomicPointer(void** a, void* v) => + byte ISdl.SetHintWithPriority( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + HintPriority priority + ) => ( - (delegate* unmanaged)( - _slots[686] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[899] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[686] = nativeContext.LoadFunction("SDL_SetAtomicPointer", "SDL3") + : _slots[899] = nativeContext.LoadFunction("SDL_SetHintWithPriority", "SDL3") ) - )(a, v); + )(name, value, priority); - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void* SetAtomicPointer(void** a, void* v) => DllImport.SetAtomicPointer(a, v); + public static byte SetHintWithPriority( + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value, + HintPriority priority + ) => DllImport.SetHintWithPriority(name, value, priority); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Ptr ISdl.SetAtomicPointer(Ref2D a, Ref v) + MaybeBool ISdl.SetHintWithPriority( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + HintPriority priority + ) { - fixed (void* __dsl_v = v) - fixed (void** __dsl_a = a) + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - return (void*)((ISdl)this).SetAtomicPointer(__dsl_a, __dsl_v); + return (MaybeBool) + (byte)((ISdl)this).SetHintWithPriority(__dsl_name, __dsl_value, priority); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Ptr SetAtomicPointer(Ref2D a, Ref v) => DllImport.SetAtomicPointer(a, v); + public static MaybeBool SetHintWithPriority( + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value, + HintPriority priority + ) => DllImport.SetHintWithPriority(name, value, priority); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => + void ISdl.SetInitialized(InitState* state, [NativeTypeName("bool")] byte initialized) => ( - (delegate* unmanaged)( - _slots[687] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[900] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[687] = nativeContext.LoadFunction("SDL_SetAtomicU32", "SDL3") + : _slots[900] = nativeContext.LoadFunction("SDL_SetInitialized", "SDL3") ) - )(a, v); + )(state, initialized); - [return: NativeTypeName("Uint32")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint SetAtomicU32(AtomicU32* a, [NativeTypeName("Uint32")] uint v) => - DllImport.SetAtomicU32(a, v); + public static void SetInitialized( + InitState* state, + [NativeTypeName("bool")] byte initialized + ) => DllImport.SetInitialized(state, initialized); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - uint ISdl.SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) + void ISdl.SetInitialized( + Ref state, + [NativeTypeName("bool")] MaybeBool initialized + ) { - fixed (AtomicU32* __dsl_a = a) + fixed (InitState* __dsl_state = state) { - return (uint)((ISdl)this).SetAtomicU32(__dsl_a, v); + ((ISdl)this).SetInitialized(__dsl_state, (byte)initialized); } } - [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAtomicU32")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static uint SetAtomicU32(Ref a, [NativeTypeName("Uint32")] uint v) => - DllImport.SetAtomicU32(a, v); + public static void SetInitialized( + Ref state, + [NativeTypeName("bool")] MaybeBool initialized + ) => DllImport.SetInitialized(state, initialized); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioDeviceGain( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => (MaybeBool)(byte)((ISdl)this).SetAudioDeviceGainRaw(devid, gain); + void ISdl.SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => + ( + (delegate* unmanaged)( + _slots[901] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[901] = nativeContext.LoadFunction( + "SDL_SetJoystickEventsEnabled", + "SDL3" + ) + ) + )(enabled); + + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => + DllImport.SetJoystickEventsEnabled(enabled); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + ((ISdl)this).SetJoystickEventsEnabled((byte)enabled); - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioDeviceGain( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => DllImport.SetAudioDeviceGain(devid, gain); + public static void SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => + DllImport.SetJoystickEventsEnabled(enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioDeviceGainRaw([NativeTypeName("SDL_AudioDeviceID")] uint devid, float gain) => - ( - (delegate* unmanaged)( - _slots[688] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[688] = nativeContext.LoadFunction("SDL_SetAudioDeviceGain", "SDL3") - ) - )(devid, gain); + MaybeBool ISdl.SetJoystickLED( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => (MaybeBool)(byte)((ISdl)this).SetJoystickLEDRaw(joystick, red, green, blue); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioDeviceGain")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioDeviceGainRaw( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - float gain - ) => DllImport.SetAudioDeviceGainRaw(devid, gain); + public static MaybeBool SetJoystickLED( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => DllImport.SetJoystickLED(joystick, red, green, blue); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - void* userdata + byte ISdl.SetJoystickLEDRaw( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue ) => ( - (delegate* unmanaged)( - _slots[689] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[902] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[689] = nativeContext.LoadFunction( - "SDL_SetAudioPostmixCallback", - "SDL3" - ) + : _slots[902] = nativeContext.LoadFunction("SDL_SetJoystickLED", "SDL3") ) - )(devid, callback, userdata); + )(joystick, red, green, blue); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - void* userdata - ) => DllImport.SetAudioPostmixCallback(devid, callback, userdata); + public static byte SetJoystickLEDRaw( + JoystickHandle joystick, + [NativeTypeName("Uint8")] byte red, + [NativeTypeName("Uint8")] byte green, + [NativeTypeName("Uint8")] byte blue + ) => DllImport.SetJoystickLEDRaw(joystick, red, green, blue); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (MaybeBool) - (byte)((ISdl)this).SetAudioPostmixCallback(devid, callback, __dsl_userdata); - } - } + MaybeBool ISdl.SetJoystickPlayerIndex(JoystickHandle joystick, int player_index) => + (MaybeBool)(byte)((ISdl)this).SetJoystickPlayerIndexRaw(joystick, player_index); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioPostmixCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioPostmixCallback( - [NativeTypeName("SDL_AudioDeviceID")] uint devid, - [NativeTypeName("SDL_AudioPostmixCallback")] AudioPostmixCallback callback, - Ref userdata - ) => DllImport.SetAudioPostmixCallback(devid, callback, userdata); + public static MaybeBool SetJoystickPlayerIndex( + JoystickHandle joystick, + int player_index + ) => DllImport.SetJoystickPlayerIndex(joystick, player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => + byte ISdl.SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => ( - (delegate* unmanaged)( - _slots[690] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[903] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[690] = nativeContext.LoadFunction("SDL_SetAudioStreamFormat", "SDL3") + : _slots[903] = nativeContext.LoadFunction("SDL_SetJoystickPlayerIndex", "SDL3") ) - )(stream, src_spec, dst_spec); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* src_spec, - [NativeTypeName("const SDL_AudioSpec *")] AudioSpec* dst_spec - ) => DllImport.SetAudioStreamFormat(stream, src_spec, dst_spec); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) - { - fixed (AudioSpec* __dsl_dst_spec = dst_spec) - fixed (AudioSpec* __dsl_src_spec = src_spec) - { - return (MaybeBool) - (byte)((ISdl)this).SetAudioStreamFormat(stream, __dsl_src_spec, __dsl_dst_spec); - } - } + )(joystick, player_index); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFormat")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamFormat( - AudioStreamHandle stream, - [NativeTypeName("const SDL_AudioSpec *")] Ref src_spec, - [NativeTypeName("const SDL_AudioSpec *")] Ref dst_spec - ) => DllImport.SetAudioStreamFormat(stream, src_spec, dst_spec); + public static byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => + DllImport.SetJoystickPlayerIndexRaw(joystick, player_index); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamFrequencyRatio(AudioStreamHandle stream, float ratio) => - (MaybeBool)(byte)((ISdl)this).SetAudioStreamFrequencyRatioRaw(stream, ratio); + MaybeBool ISdl.SetJoystickVirtualAxis( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualAxisRaw(joystick, axis, value); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamFrequencyRatio( - AudioStreamHandle stream, - float ratio - ) => DllImport.SetAudioStreamFrequencyRatio(stream, ratio); + public static MaybeBool SetJoystickVirtualAxis( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => DllImport.SetJoystickVirtualAxis(joystick, axis, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => + byte ISdl.SetJoystickVirtualAxisRaw( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => ( - (delegate* unmanaged)( - _slots[691] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[904] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[691] = nativeContext.LoadFunction( - "SDL_SetAudioStreamFrequencyRatio", - "SDL3" - ) + : _slots[904] = nativeContext.LoadFunction("SDL_SetJoystickVirtualAxis", "SDL3") ) - )(stream, ratio); + )(joystick, axis, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamFrequencyRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamFrequencyRatioRaw(AudioStreamHandle stream, float ratio) => - DllImport.SetAudioStreamFrequencyRatioRaw(stream, ratio); + public static byte SetJoystickVirtualAxisRaw( + JoystickHandle joystick, + int axis, + [NativeTypeName("Sint16")] short value + ) => DllImport.SetJoystickVirtualAxisRaw(joystick, axis, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamGain(AudioStreamHandle stream, float gain) => - (MaybeBool)(byte)((ISdl)this).SetAudioStreamGainRaw(stream, gain); + MaybeBool ISdl.SetJoystickVirtualBall( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamGain(AudioStreamHandle stream, float gain) => - DllImport.SetAudioStreamGain(stream, gain); + public static MaybeBool SetJoystickVirtualBall( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => DllImport.SetJoystickVirtualBall(joystick, ball, xrel, yrel); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => + byte ISdl.SetJoystickVirtualBallRaw( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => ( - (delegate* unmanaged)( - _slots[692] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[905] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[692] = nativeContext.LoadFunction("SDL_SetAudioStreamGain", "SDL3") + : _slots[905] = nativeContext.LoadFunction("SDL_SetJoystickVirtualBall", "SDL3") ) - )(stream, gain); + )(joystick, ball, xrel, yrel); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamGainRaw(AudioStreamHandle stream, float gain) => - DllImport.SetAudioStreamGainRaw(stream, gain); + public static byte SetJoystickVirtualBallRaw( + JoystickHandle joystick, + int ball, + [NativeTypeName("Sint16")] short xrel, + [NativeTypeName("Sint16")] short yrel + ) => DllImport.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata + byte ISdl.SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] byte down ) => ( - (delegate* unmanaged)( - _slots[693] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[906] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[693] = nativeContext.LoadFunction( - "SDL_SetAudioStreamGetCallback", + : _slots[906] = nativeContext.LoadFunction( + "SDL_SetJoystickVirtualButton", "SDL3" ) ) - )(stream, callback, userdata); + )(joystick, button, down); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - void* userdata - ) => DllImport.SetAudioStreamGetCallback(stream, callback, userdata); + public static byte SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] byte down + ) => DllImport.SetJoystickVirtualButton(joystick, button, down); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) - { - fixed (void* __dsl_userdata = userdata) - { - return (MaybeBool) - (byte)((ISdl)this).SetAudioStreamGetCallback(stream, callback, __dsl_userdata); - } - } + MaybeBool ISdl.SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] MaybeBool down + ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualButton(joystick, button, (byte)down); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamGetCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamGetCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, - Ref userdata - ) => DllImport.SetAudioStreamGetCallback(stream, callback, userdata); + public static MaybeBool SetJoystickVirtualButton( + JoystickHandle joystick, + int button, + [NativeTypeName("bool")] MaybeBool down + ) => DllImport.SetJoystickVirtualButton(joystick, button, down); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => - ( - (delegate* unmanaged)( - _slots[694] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[694] = nativeContext.LoadFunction( - "SDL_SetAudioStreamInputChannelMap", - "SDL3" - ) - ) - )(stream, chmap, count); + MaybeBool ISdl.SetJoystickVirtualHat( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualHatRaw(joystick, hat, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => DllImport.SetAudioStreamInputChannelMap(stream, chmap, count); + public static MaybeBool SetJoystickVirtualHat( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => DllImport.SetJoystickVirtualHat(joystick, hat, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) - { - fixed (int* __dsl_chmap = chmap) - { - return (MaybeBool) - (byte)((ISdl)this).SetAudioStreamInputChannelMap(stream, __dsl_chmap, count); - } - } + byte ISdl.SetJoystickVirtualHatRaw( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => + ( + (delegate* unmanaged)( + _slots[907] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[907] = nativeContext.LoadFunction("SDL_SetJoystickVirtualHat", "SDL3") + ) + )(joystick, hat, value); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamInputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamInputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) => DllImport.SetAudioStreamInputChannelMap(stream, chmap, count); + public static byte SetJoystickVirtualHatRaw( + JoystickHandle joystick, + int hat, + [NativeTypeName("Uint8")] byte value + ) => DllImport.SetJoystickVirtualHatRaw(joystick, hat, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count + byte ISdl.SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] byte down, + float x, + float y, + float pressure ) => ( - (delegate* unmanaged)( - _slots[695] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[908] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[695] = nativeContext.LoadFunction( - "SDL_SetAudioStreamOutputChannelMap", + : _slots[908] = nativeContext.LoadFunction( + "SDL_SetJoystickVirtualTouchpad", "SDL3" ) ) - )(stream, chmap, count); + )(joystick, touchpad, finger, down, x, y, pressure); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] int* chmap, - int count - ) => DllImport.SetAudioStreamOutputChannelMap(stream, chmap, count); + public static byte SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] byte down, + float x, + float y, + float pressure + ) => DllImport.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) - { - fixed (int* __dsl_chmap = chmap) - { - return (MaybeBool) - (byte)((ISdl)this).SetAudioStreamOutputChannelMap(stream, __dsl_chmap, count); - } - } + MaybeBool ISdl.SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] MaybeBool down, + float x, + float y, + float pressure + ) => + (MaybeBool) + (byte) + ((ISdl)this).SetJoystickVirtualTouchpad( + joystick, + touchpad, + finger, + (byte)down, + x, + y, + pressure + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamOutputChannelMap")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamOutputChannelMap( - AudioStreamHandle stream, - [NativeTypeName("const int *")] Ref chmap, - int count - ) => DllImport.SetAudioStreamOutputChannelMap(stream, chmap, count); + public static MaybeBool SetJoystickVirtualTouchpad( + JoystickHandle joystick, + int touchpad, + int finger, + [NativeTypeName("bool")] MaybeBool down, + float x, + float y, + float pressure + ) => DllImport.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void ISdl.SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, void* userdata ) => ( - (delegate* unmanaged)( - _slots[696] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[909] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[696] = nativeContext.LoadFunction( - "SDL_SetAudioStreamPutCallback", - "SDL3" - ) + : _slots[909] = nativeContext.LoadFunction("SDL_SetLogOutputFunction", "SDL3") ) - )(stream, callback, userdata); + )(callback, userdata); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + public static void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, void* userdata - ) => DllImport.SetAudioStreamPutCallback(stream, callback, userdata); + ) => DllImport.SetLogOutputFunction(callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + void ISdl.SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, Ref userdata ) { fixed (void* __dsl_userdata = userdata) { - return (MaybeBool) - (byte)((ISdl)this).SetAudioStreamPutCallback(stream, callback, __dsl_userdata); + ((ISdl)this).SetLogOutputFunction(callback, __dsl_userdata); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetAudioStreamPutCallback")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetAudioStreamPutCallback( - AudioStreamHandle stream, - [NativeTypeName("SDL_AudioStreamCallback")] AudioStreamCallback callback, + public static void SetLogOutputFunction( + [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, Ref userdata - ) => DllImport.SetAudioStreamPutCallback(stream, callback, userdata); + ) => DllImport.SetLogOutputFunction(callback, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte value - ) => + void ISdl.SetLogPriorities(LogPriority priority) => ( - (delegate* unmanaged)( - _slots[697] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[910] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[697] = nativeContext.LoadFunction("SDL_SetBooleanProperty", "SDL3") + : _slots[910] = nativeContext.LoadFunction("SDL_SetLogPriorities", "SDL3") ) - )(props, name, value); + )(priority); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("bool")] byte value - ) => DllImport.SetBooleanProperty(props, name, value); + public static void SetLogPriorities(LogPriority priority) => + DllImport.SetLogPriorities(priority); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool value - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool) - (byte)((ISdl)this).SetBooleanProperty(props, __dsl_name, (byte)value); - } - } + void ISdl.SetLogPriority(int category, LogPriority priority) => + ( + (delegate* unmanaged)( + _slots[911] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[911] = nativeContext.LoadFunction("SDL_SetLogPriority", "SDL3") + ) + )(category, priority); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetBooleanProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetBooleanProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("bool")] MaybeBool value - ) => DllImport.SetBooleanProperty(props, name, value); + public static void SetLogPriority(int category, LogPriority priority) => + DllImport.SetLogPriority(category, priority); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - void* userdata, - [NativeTypeName("const char **")] sbyte** mime_types, - [NativeTypeName("size_t")] nuint num_mime_types + byte ISdl.SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] sbyte* prefix ) => ( - (delegate* unmanaged< - ClipboardDataCallback, - ClipboardCleanupCallback, - void*, - sbyte**, - nuint, - byte>)( - _slots[698] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[912] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[698] = nativeContext.LoadFunction("SDL_SetClipboardData", "SDL3") + : _slots[912] = nativeContext.LoadFunction("SDL_SetLogPriorityPrefix", "SDL3") ) - )(callback, cleanup, userdata, mime_types, num_mime_types); + )(priority, prefix); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - void* userdata, - [NativeTypeName("const char **")] sbyte** mime_types, - [NativeTypeName("size_t")] nuint num_mime_types - ) => DllImport.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); + public static byte SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] sbyte* prefix + ) => DllImport.SetLogPriorityPrefix(priority, prefix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - Ref userdata, - [NativeTypeName("const char **")] Ref2D mime_types, - [NativeTypeName("size_t")] nuint num_mime_types + MaybeBool ISdl.SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] Ref prefix ) { - fixed (sbyte** __dsl_mime_types = mime_types) - fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_prefix = prefix) { - return (MaybeBool) - (byte) - ((ISdl)this).SetClipboardData( - callback, - cleanup, - __dsl_userdata, - __dsl_mime_types, - num_mime_types - ); + return (MaybeBool)(byte)((ISdl)this).SetLogPriorityPrefix(priority, __dsl_prefix); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardData")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetClipboardData( - [NativeTypeName("SDL_ClipboardDataCallback")] ClipboardDataCallback callback, - [NativeTypeName("SDL_ClipboardCleanupCallback")] ClipboardCleanupCallback cleanup, - Ref userdata, - [NativeTypeName("const char **")] Ref2D mime_types, - [NativeTypeName("size_t")] nuint num_mime_types - ) => DllImport.SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); + public static MaybeBool SetLogPriorityPrefix( + LogPriority priority, + [NativeTypeName("const char *")] Ref prefix + ) => DllImport.SetLogPriorityPrefix(priority, prefix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetClipboardText([NativeTypeName("const char *")] sbyte* text) => + void ISdl.SetMainReady() => ( - (delegate* unmanaged)( - _slots[699] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[913] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[699] = nativeContext.LoadFunction("SDL_SetClipboardText", "SDL3") + : _slots[913] = nativeContext.LoadFunction("SDL_SetMainReady", "SDL3") ) - )(text); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetClipboardText([NativeTypeName("const char *")] sbyte* text) => - DllImport.SetClipboardText(text); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetClipboardText([NativeTypeName("const char *")] Ref text) - { - fixed (sbyte* __dsl_text = text) - { - return (MaybeBool)(byte)((ISdl)this).SetClipboardText(__dsl_text); - } - } + )(); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetClipboardText")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMainReady")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetClipboardText( - [NativeTypeName("const char *")] Ref text - ) => DllImport.SetClipboardText(text); + public static void SetMainReady() => DllImport.SetMainReady(); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetCurrentThreadPriority(ThreadPriority priority) => - (MaybeBool)(byte)((ISdl)this).SetCurrentThreadPriorityRaw(priority); + MaybeBool ISdl.SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => + (MaybeBool) + (byte) + ((ISdl)this).SetMemoryFunctionsRaw( + malloc_func, + calloc_func, + realloc_func, + free_func + ); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetCurrentThreadPriority(ThreadPriority priority) => - DllImport.SetCurrentThreadPriority(priority); + public static MaybeBool SetMemoryFunctions( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => DllImport.SetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetCurrentThreadPriorityRaw(ThreadPriority priority) => + byte ISdl.SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => ( - (delegate* unmanaged)( - _slots[700] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[914] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[700] = nativeContext.LoadFunction( - "SDL_SetCurrentThreadPriority", - "SDL3" - ) + : _slots[914] = nativeContext.LoadFunction("SDL_SetMemoryFunctions", "SDL3") ) - )(priority); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCurrentThreadPriority")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetCurrentThreadPriorityRaw(ThreadPriority priority) => - DllImport.SetCurrentThreadPriorityRaw(priority); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetCursor(CursorHandle cursor) => - (MaybeBool)(byte)((ISdl)this).SetCursorRaw(cursor); + )(malloc_func, calloc_func, realloc_func, free_func); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetMemoryFunctions")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetCursor(CursorHandle cursor) => DllImport.SetCursor(cursor); + public static byte SetMemoryFunctionsRaw( + [NativeTypeName("SDL_malloc_func")] MallocFunc malloc_func, + [NativeTypeName("SDL_calloc_func")] CallocFunc calloc_func, + [NativeTypeName("SDL_realloc_func")] ReallocFunc realloc_func, + [NativeTypeName("SDL_free_func")] FreeFunc free_func + ) => DllImport.SetMemoryFunctionsRaw(malloc_func, calloc_func, realloc_func, free_func); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetCursorRaw(CursorHandle cursor) => + void ISdl.SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => ( - (delegate* unmanaged)( - _slots[701] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[915] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[701] = nativeContext.LoadFunction("SDL_SetCursor", "SDL3") + : _slots[915] = nativeContext.LoadFunction("SDL_SetModState", "SDL3") ) - )(cursor); + )(modstate); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetCursorRaw(CursorHandle cursor) => DllImport.SetCursorRaw(cursor); + public static void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => + DllImport.SetModState(modstate); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetErrorV( - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap + byte ISdl.SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long value ) => ( - (delegate* unmanaged)( - _slots[702] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[916] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[702] = nativeContext.LoadFunction("SDL_SetErrorV", "SDL3") + : _slots[916] = nativeContext.LoadFunction("SDL_SetNumberProperty", "SDL3") ) - )(fmt, ap); + )(props, name, value); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetErrorV( - [NativeTypeName("const char *")] sbyte* fmt, - [NativeTypeName("va_list")] sbyte* ap - ) => DllImport.SetErrorV(fmt, ap); + public static byte SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("Sint64")] long value + ) => DllImport.SetNumberProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetErrorV( - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap + MaybeBool ISdl.SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long value ) { - fixed (sbyte* __dsl_ap = ap) - fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).SetErrorV(__dsl_fmt, __dsl_ap); + return (MaybeBool)(byte)((ISdl)this).SetNumberProperty(props, __dsl_name, value); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetErrorV")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetErrorV( - [NativeTypeName("const char *")] Ref fmt, - [NativeTypeName("va_list")] Ref ap - ) => DllImport.SetErrorV(fmt, ap); + public static MaybeBool SetNumberProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("Sint64")] long value + ) => DllImport.SetNumberProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] byte enabled + byte ISdl.SetPaletteColors( + Palette* palette, + [NativeTypeName("const SDL_Color *")] Color* colors, + int firstcolor, + int ncolors ) => ( - (delegate* unmanaged)( - _slots[703] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[917] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[703] = nativeContext.LoadFunction("SDL_SetEventEnabled", "SDL3") + : _slots[917] = nativeContext.LoadFunction("SDL_SetPaletteColors", "SDL3") ) - )(type, enabled); + )(palette, colors, firstcolor, ncolors); - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] byte enabled - ) => DllImport.SetEventEnabled(type, enabled); + public static byte SetPaletteColors( + Palette* palette, + [NativeTypeName("const SDL_Color *")] Color* colors, + int firstcolor, + int ncolors + ) => DllImport.SetPaletteColors(palette, colors, firstcolor, ncolors); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] MaybeBool enabled - ) => ((ISdl)this).SetEventEnabled(type, (byte)enabled); + MaybeBool ISdl.SetPaletteColors( + Ref palette, + [NativeTypeName("const SDL_Color *")] Ref colors, + int firstcolor, + int ncolors + ) + { + fixed (Color* __dsl_colors = colors) + fixed (Palette* __dsl_palette = palette) + { + return (MaybeBool) + (byte) + ((ISdl)this).SetPaletteColors(__dsl_palette, __dsl_colors, firstcolor, ncolors); + } + } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetEventEnabled( - [NativeTypeName("Uint32")] uint type, - [NativeTypeName("bool")] MaybeBool enabled - ) => DllImport.SetEventEnabled(type, enabled); + public static MaybeBool SetPaletteColors( + Ref palette, + [NativeTypeName("const SDL_Color *")] Ref colors, + int firstcolor, + int ncolors + ) => DllImport.SetPaletteColors(palette, colors, firstcolor, ncolors); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata + byte ISdl.SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value ) => ( - (delegate* unmanaged)( - _slots[704] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[918] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[704] = nativeContext.LoadFunction("SDL_SetEventFilter", "SDL3") + : _slots[918] = nativeContext.LoadFunction("SDL_SetPointerProperty", "SDL3") ) - )(filter, userdata); + )(props, name, value); - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - void* userdata - ) => DllImport.SetEventFilter(filter, userdata); + public static byte SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + void* value + ) => DllImport.SetPointerProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetEventFilter([NativeTypeName("SDL_EventFilter")] EventFilter filter, Ref userdata) + MaybeBool ISdl.SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value + ) { - fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_value = value) + fixed (sbyte* __dsl_name = name) { - ((ISdl)this).SetEventFilter(filter, __dsl_userdata); + return (MaybeBool) + (byte)((ISdl)this).SetPointerProperty(props, __dsl_name, __dsl_value); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetEventFilter")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetEventFilter( - [NativeTypeName("SDL_EventFilter")] EventFilter filter, - Ref userdata - ) => DllImport.SetEventFilter(filter, userdata); + public static MaybeBool SetPointerProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + Ref value + ) => DllImport.SetPointerProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetFloatProperty( + byte ISdl.SetPointerPropertyWithCleanup( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] sbyte* name, - float value + void* value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + void* userdata ) => ( - (delegate* unmanaged)( - _slots[705] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[919] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[705] = nativeContext.LoadFunction("SDL_SetFloatProperty", "SDL3") + : _slots[919] = nativeContext.LoadFunction( + "SDL_SetPointerPropertyWithCleanup", + "SDL3" + ) ) - )(props, name, value); + )(props, name, value, cleanup, userdata); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetFloatProperty( + public static byte SetPointerPropertyWithCleanup( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] sbyte* name, - float value - ) => DllImport.SetFloatProperty(props, name, value); + void* value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + void* userdata + ) => DllImport.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetFloatProperty( + MaybeBool ISdl.SetPointerPropertyWithCleanup( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] Ref name, - float value + Ref value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + Ref userdata ) { + fixed (void* __dsl_userdata = userdata) + fixed (void* __dsl_value = value) fixed (sbyte* __dsl_name = name) { - return (MaybeBool)(byte)((ISdl)this).SetFloatProperty(props, __dsl_name, value); + return (MaybeBool) + (byte) + ((ISdl)this).SetPointerPropertyWithCleanup( + props, + __dsl_name, + __dsl_value, + cleanup, + __dsl_userdata + ); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetFloatProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetFloatProperty( + public static MaybeBool SetPointerPropertyWithCleanup( [NativeTypeName("SDL_PropertiesID")] uint props, [NativeTypeName("const char *")] Ref name, - float value - ) => DllImport.SetFloatProperty(props, name, value); + Ref value, + [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, + Ref userdata + ) => DllImport.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => + byte ISdl.SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => ( - (delegate* unmanaged)( - _slots[706] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[920] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[706] = nativeContext.LoadFunction( - "SDL_SetGamepadEventsEnabled", + : _slots[920] = nativeContext.LoadFunction( + "SDL_SetPrimarySelectionText", "SDL3" ) ) - )(enabled); + )(text); - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetGamepadEventsEnabled([NativeTypeName("bool")] byte enabled) => - DllImport.SetGamepadEventsEnabled(enabled); + public static byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => + DllImport.SetPrimarySelectionText(text); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - ((ISdl)this).SetGamepadEventsEnabled((byte)enabled); + MaybeBool ISdl.SetPrimarySelectionText([NativeTypeName("const char *")] Ref text) + { + fixed (sbyte* __dsl_text = text) + { + return (MaybeBool)(byte)((ISdl)this).SetPrimarySelectionText(__dsl_text); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetPrimarySelectionText( + [NativeTypeName("const char *")] Ref text + ) => DllImport.SetPrimarySelectionText(text); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => + ( + (delegate* unmanaged)( + _slots[921] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[921] = nativeContext.LoadFunction("SDL_SetRenderClipRect", "SDL3") + ) + )(renderer, rect); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => DllImport.SetRenderClipRect(renderer, rect); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)((ISdl)this).SetRenderClipRect(renderer, __dsl_rect); + } + } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadEventsEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetGamepadEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - DllImport.SetGamepadEventsEnabled(enabled); + public static MaybeBool SetRenderClipRect( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => DllImport.SetRenderClipRect(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetGamepadLED( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => (MaybeBool)(byte)((ISdl)this).SetGamepadLEDRaw(gamepad, red, green, blue); + MaybeBool ISdl.SetRenderColorScale(RendererHandle renderer, float scale) => + (MaybeBool)(byte)((ISdl)this).SetRenderColorScaleRaw(renderer, scale); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetGamepadLED( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => DllImport.SetGamepadLED(gamepad, red, green, blue); + public static MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => + DllImport.SetRenderColorScale(renderer, scale); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetGamepadLEDRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => + byte ISdl.SetRenderColorScaleRaw(RendererHandle renderer, float scale) => ( - (delegate* unmanaged)( - _slots[707] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[922] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[707] = nativeContext.LoadFunction("SDL_SetGamepadLED", "SDL3") + : _slots[922] = nativeContext.LoadFunction("SDL_SetRenderColorScale", "SDL3") ) - )(gamepad, red, green, blue); + )(renderer, scale); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetGamepadLEDRaw( - GamepadHandle gamepad, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => DllImport.SetGamepadLEDRaw(gamepad, red, green, blue); + public static byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => + DllImport.SetRenderColorScaleRaw(renderer, scale); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] sbyte* mapping + MaybeBool ISdl.SetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawBlendModeRaw(renderer, blendMode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetRenderDrawBlendMode( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetRenderDrawBlendMode(renderer, blendMode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetRenderDrawBlendModeRaw( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode ) => ( - (delegate* unmanaged)( - _slots[708] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[923] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[708] = nativeContext.LoadFunction("SDL_SetGamepadMapping", "SDL3") + : _slots[923] = nativeContext.LoadFunction("SDL_SetRenderDrawBlendMode", "SDL3") ) - )(instance_id, mapping); + )(renderer, blendMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] sbyte* mapping - ) => DllImport.SetGamepadMapping(instance_id, mapping); + public static byte SetRenderDrawBlendModeRaw( + RendererHandle renderer, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetRenderDrawBlendModeRaw(renderer, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] Ref mapping - ) - { - fixed (sbyte* __dsl_mapping = mapping) - { - return (MaybeBool) - (byte)((ISdl)this).SetGamepadMapping(instance_id, __dsl_mapping); - } - } + MaybeBool ISdl.SetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawColorRaw(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadMapping")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetGamepadMapping( - [NativeTypeName("SDL_JoystickID")] uint instance_id, - [NativeTypeName("const char *")] Ref mapping - ) => DllImport.SetGamepadMapping(instance_id, mapping); + public static MaybeBool SetRenderDrawColor( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.SetRenderDrawColor(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => - (MaybeBool)(byte)((ISdl)this).SetGamepadPlayerIndexRaw(gamepad, player_index); + MaybeBool ISdl.SetRenderDrawColorFloat( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawColorFloatRaw(renderer, r, g, b, a); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetGamepadPlayerIndex(GamepadHandle gamepad, int player_index) => - DllImport.SetGamepadPlayerIndex(gamepad, player_index); + public static MaybeBool SetRenderDrawColorFloat( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => DllImport.SetRenderDrawColorFloat(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => + byte ISdl.SetRenderDrawColorFloatRaw( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => ( - (delegate* unmanaged)( - _slots[709] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[925] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[709] = nativeContext.LoadFunction("SDL_SetGamepadPlayerIndex", "SDL3") + : _slots[925] = nativeContext.LoadFunction( + "SDL_SetRenderDrawColorFloat", + "SDL3" + ) ) - )(gamepad, player_index); + )(renderer, r, g, b, a); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetGamepadPlayerIndexRaw(GamepadHandle gamepad, int player_index) => - DllImport.SetGamepadPlayerIndexRaw(gamepad, player_index); + public static byte SetRenderDrawColorFloatRaw( + RendererHandle renderer, + float r, + float g, + float b, + float a + ) => DllImport.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] byte enabled + byte ISdl.SetRenderDrawColorRaw( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a ) => ( - (delegate* unmanaged)( - _slots[710] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[924] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[710] = nativeContext.LoadFunction( - "SDL_SetGamepadSensorEnabled", - "SDL3" - ) + : _slots[924] = nativeContext.LoadFunction("SDL_SetRenderDrawColor", "SDL3") ) - )(gamepad, type, enabled); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] byte enabled - ) => DllImport.SetGamepadSensorEnabled(gamepad, type, enabled); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] MaybeBool enabled - ) => (MaybeBool)(byte)((ISdl)this).SetGamepadSensorEnabled(gamepad, type, (byte)enabled); + )(renderer, r, g, b, a); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetGamepadSensorEnabled")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetGamepadSensorEnabled( - GamepadHandle gamepad, - SensorType type, - [NativeTypeName("bool")] MaybeBool enabled - ) => DllImport.SetGamepadSensorEnabled(gamepad, type, enabled); + public static byte SetRenderDrawColorRaw( + RendererHandle renderer, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b, + [NativeTypeName("Uint8")] byte a + ) => DllImport.SetRenderDrawColorRaw(renderer, r, g, b, a); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetHapticAutocenter(HapticHandle haptic, int autocenter) => - (MaybeBool)(byte)((ISdl)this).SetHapticAutocenterRaw(haptic, autocenter); + MaybeBool ISdl.SetRenderLogicalPresentation( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => (MaybeBool)(byte)((ISdl)this).SetRenderLogicalPresentationRaw(renderer, w, h, mode); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetHapticAutocenter(HapticHandle haptic, int autocenter) => - DllImport.SetHapticAutocenter(haptic, autocenter); + public static MaybeBool SetRenderLogicalPresentation( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => DllImport.SetRenderLogicalPresentation(renderer, w, h, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => + byte ISdl.SetRenderLogicalPresentationRaw( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => ( - (delegate* unmanaged)( - _slots[711] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[926] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[711] = nativeContext.LoadFunction("SDL_SetHapticAutocenter", "SDL3") + : _slots[926] = nativeContext.LoadFunction( + "SDL_SetRenderLogicalPresentation", + "SDL3" + ) ) - )(haptic, autocenter); + )(renderer, w, h, mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticAutocenter")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetHapticAutocenterRaw(HapticHandle haptic, int autocenter) => - DllImport.SetHapticAutocenterRaw(haptic, autocenter); + public static byte SetRenderLogicalPresentationRaw( + RendererHandle renderer, + int w, + int h, + RendererLogicalPresentation mode + ) => DllImport.SetRenderLogicalPresentationRaw(renderer, w, h, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetHapticGain(HapticHandle haptic, int gain) => - (MaybeBool)(byte)((ISdl)this).SetHapticGainRaw(haptic, gain); + MaybeBool ISdl.SetRenderScale(RendererHandle renderer, float scaleX, float scaleY) => + (MaybeBool)(byte)((ISdl)this).SetRenderScaleRaw(renderer, scaleX, scaleY); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetHapticGain(HapticHandle haptic, int gain) => - DllImport.SetHapticGain(haptic, gain); + public static MaybeBool SetRenderScale( + RendererHandle renderer, + float scaleX, + float scaleY + ) => DllImport.SetRenderScale(renderer, scaleX, scaleY); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetHapticGainRaw(HapticHandle haptic, int gain) => + byte ISdl.SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => ( - (delegate* unmanaged)( - _slots[712] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[927] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[712] = nativeContext.LoadFunction("SDL_SetHapticGain", "SDL3") + : _slots[927] = nativeContext.LoadFunction("SDL_SetRenderScale", "SDL3") ) - )(haptic, gain); + )(renderer, scaleX, scaleY); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHapticGain")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetHapticGainRaw(HapticHandle haptic, int gain) => - DllImport.SetHapticGainRaw(haptic, gain); + public static byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => + DllImport.SetRenderScaleRaw(renderer, scaleX, scaleY); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetHint( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => + byte ISdl.SetRenderTarget(RendererHandle renderer, Texture* texture) => ( - (delegate* unmanaged)( - _slots[713] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[928] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[713] = nativeContext.LoadFunction("SDL_SetHint", "SDL3") + : _slots[928] = nativeContext.LoadFunction("SDL_SetRenderTarget", "SDL3") ) - )(name, value); + )(renderer, texture); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetHint( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => DllImport.SetHint(name, value); + public static byte SetRenderTarget(RendererHandle renderer, Texture* texture) => + DllImport.SetRenderTarget(renderer, texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetHint( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) + MaybeBool ISdl.SetRenderTarget(RendererHandle renderer, Ref texture) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).SetHint(__dsl_name, __dsl_value); + return (MaybeBool)(byte)((ISdl)this).SetRenderTarget(renderer, __dsl_texture); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHint")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetHint( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => DllImport.SetHint(name, value); + public static MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) => + DllImport.SetRenderTarget(renderer, texture); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetHintWithPriority( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value, - HintPriority priority + byte ISdl.SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect ) => ( - (delegate* unmanaged)( - _slots[714] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[929] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[714] = nativeContext.LoadFunction("SDL_SetHintWithPriority", "SDL3") + : _slots[929] = nativeContext.LoadFunction("SDL_SetRenderViewport", "SDL3") ) - )(name, value, priority); + )(renderer, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetHintWithPriority( - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value, - HintPriority priority - ) => DllImport.SetHintWithPriority(name, value, priority); + public static byte SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => DllImport.SetRenderViewport(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetHintWithPriority( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value, - HintPriority priority + MaybeBool ISdl.SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect ) { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte)((ISdl)this).SetHintWithPriority(__dsl_name, __dsl_value, priority); + return (MaybeBool)(byte)((ISdl)this).SetRenderViewport(renderer, __dsl_rect); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetHintWithPriority")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetHintWithPriority( - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value, - HintPriority priority - ) => DllImport.SetHintWithPriority(name, value, priority); + public static MaybeBool SetRenderViewport( + RendererHandle renderer, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => DllImport.SetRenderViewport(renderer, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetInitialized(InitState* state, [NativeTypeName("bool")] byte initialized) => + MaybeBool ISdl.SetRenderVSync(RendererHandle renderer, int vsync) => + (MaybeBool)(byte)((ISdl)this).SetRenderVSyncRaw(renderer, vsync); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => + DllImport.SetRenderVSync(renderer, vsync); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetRenderVSyncRaw(RendererHandle renderer, int vsync) => ( - (delegate* unmanaged)( - _slots[715] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[930] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[715] = nativeContext.LoadFunction("SDL_SetInitialized", "SDL3") + : _slots[930] = nativeContext.LoadFunction("SDL_SetRenderVSync", "SDL3") ) - )(state, initialized); + )(renderer, vsync); - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetInitialized( - InitState* state, - [NativeTypeName("bool")] byte initialized - ) => DllImport.SetInitialized(state, initialized); + public static byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => + DllImport.SetRenderVSyncRaw(renderer, vsync); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetInitialized( - Ref state, - [NativeTypeName("bool")] MaybeBool initialized + byte ISdl.SetScancodeName(Scancode scancode, [NativeTypeName("const char *")] sbyte* name) => + ( + (delegate* unmanaged)( + _slots[931] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[931] = nativeContext.LoadFunction("SDL_SetScancodeName", "SDL3") + ) + )(scancode, name); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.SetScancodeName(scancode, name); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] Ref name ) { - fixed (InitState* __dsl_state = state) + fixed (sbyte* __dsl_name = name) { - ((ISdl)this).SetInitialized(__dsl_state, (byte)initialized); + return (MaybeBool)(byte)((ISdl)this).SetScancodeName(scancode, __dsl_name); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetInitialized")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetInitialized( - Ref state, - [NativeTypeName("bool")] MaybeBool initialized - ) => DllImport.SetInitialized(state, initialized); + public static MaybeBool SetScancodeName( + Scancode scancode, + [NativeTypeName("const char *")] Ref name + ) => DllImport.SetScancodeName(scancode, name); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => + byte ISdl.SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => ( - (delegate* unmanaged)( - _slots[716] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[932] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[716] = nativeContext.LoadFunction( - "SDL_SetJoystickEventsEnabled", - "SDL3" - ) + : _slots[932] = nativeContext.LoadFunction("SDL_SetStringProperty", "SDL3") ) - )(enabled); - - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetJoystickEventsEnabled([NativeTypeName("bool")] byte enabled) => - DllImport.SetJoystickEventsEnabled(enabled); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - ((ISdl)this).SetJoystickEventsEnabled((byte)enabled); + )(props, name, value); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickEventsEnabled")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetJoystickEventsEnabled([NativeTypeName("bool")] MaybeBool enabled) => - DllImport.SetJoystickEventsEnabled(enabled); + public static byte SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] sbyte* name, + [NativeTypeName("const char *")] sbyte* value + ) => DllImport.SetStringProperty(props, name, value); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickLED( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => (MaybeBool)(byte)((ISdl)this).SetJoystickLEDRaw(joystick, red, green, blue); + MaybeBool ISdl.SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) + { + fixed (sbyte* __dsl_value = value) + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool) + (byte)((ISdl)this).SetStringProperty(props, __dsl_name, __dsl_value); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickLED( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => DllImport.SetJoystickLED(joystick, red, green, blue); - + [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickLEDRaw( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => + public static MaybeBool SetStringProperty( + [NativeTypeName("SDL_PropertiesID")] uint props, + [NativeTypeName("const char *")] Ref name, + [NativeTypeName("const char *")] Ref value + ) => DllImport.SetStringProperty(props, name, value); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => ( - (delegate* unmanaged)( - _slots[717] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[933] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[717] = nativeContext.LoadFunction("SDL_SetJoystickLED", "SDL3") + : _slots[933] = nativeContext.LoadFunction("SDL_SetSurfaceAlphaMod", "SDL3") ) - )(joystick, red, green, blue); + )(surface, alpha); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickLED")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickLEDRaw( - JoystickHandle joystick, - [NativeTypeName("Uint8")] byte red, - [NativeTypeName("Uint8")] byte green, - [NativeTypeName("Uint8")] byte blue - ) => DllImport.SetJoystickLEDRaw(joystick, red, green, blue); + public static byte SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => + DllImport.SetSurfaceAlphaMod(surface, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickPlayerIndex(JoystickHandle joystick, int player_index) => - (MaybeBool)(byte)((ISdl)this).SetJoystickPlayerIndexRaw(joystick, player_index); + MaybeBool ISdl.SetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8")] byte alpha + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)((ISdl)this).SetSurfaceAlphaMod(__dsl_surface, alpha); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickPlayerIndex( - JoystickHandle joystick, - int player_index - ) => DllImport.SetJoystickPlayerIndex(joystick, player_index); + public static MaybeBool SetSurfaceAlphaMod( + Ref surface, + [NativeTypeName("Uint8")] byte alpha + ) => DllImport.SetSurfaceAlphaMod(surface, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => + byte ISdl.SetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => ( - (delegate* unmanaged)( - _slots[718] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[934] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[718] = nativeContext.LoadFunction("SDL_SetJoystickPlayerIndex", "SDL3") + : _slots[934] = nativeContext.LoadFunction("SDL_SetSurfaceBlendMode", "SDL3") ) - )(joystick, player_index); + )(surface, blendMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickPlayerIndex")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickPlayerIndexRaw(JoystickHandle joystick, int player_index) => - DllImport.SetJoystickPlayerIndexRaw(joystick, player_index); + public static byte SetSurfaceBlendMode( + Surface* surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetSurfaceBlendMode(surface, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickVirtualAxis( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualAxisRaw(joystick, axis, value); + MaybeBool ISdl.SetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).SetSurfaceBlendMode(__dsl_surface, blendMode); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickVirtualAxis( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => DllImport.SetJoystickVirtualAxis(joystick, axis, value); + public static MaybeBool SetSurfaceBlendMode( + Ref surface, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetSurfaceBlendMode(surface, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickVirtualAxisRaw( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value + byte ISdl.SetSurfaceClipRect( + Surface* surface, + [NativeTypeName("const SDL_Rect *")] Rect* rect ) => ( - (delegate* unmanaged)( - _slots[719] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[935] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[719] = nativeContext.LoadFunction("SDL_SetJoystickVirtualAxis", "SDL3") + : _slots[935] = nativeContext.LoadFunction("SDL_SetSurfaceClipRect", "SDL3") ) - )(joystick, axis, value); + )(surface, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualAxis")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickVirtualAxisRaw( - JoystickHandle joystick, - int axis, - [NativeTypeName("Sint16")] short value - ) => DllImport.SetJoystickVirtualAxisRaw(joystick, axis, value); + public static byte SetSurfaceClipRect( + Surface* surface, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => DllImport.SetSurfaceClipRect(surface, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickVirtualBall( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); + MaybeBool ISdl.SetSurfaceClipRect( + Ref surface, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) + { + fixed (Rect* __dsl_rect = rect) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).SetSurfaceClipRect(__dsl_surface, __dsl_rect); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickVirtualBall( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => DllImport.SetJoystickVirtualBall(joystick, ball, xrel, yrel); + public static MaybeBool SetSurfaceClipRect( + Ref surface, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => DllImport.SetSurfaceClipRect(surface, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickVirtualBallRaw( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel + byte ISdl.SetSurfaceColorKey( + Surface* surface, + [NativeTypeName("bool")] byte enabled, + [NativeTypeName("Uint32")] uint key ) => ( - (delegate* unmanaged)( - _slots[720] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[936] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[720] = nativeContext.LoadFunction("SDL_SetJoystickVirtualBall", "SDL3") + : _slots[936] = nativeContext.LoadFunction("SDL_SetSurfaceColorKey", "SDL3") ) - )(joystick, ball, xrel, yrel); + )(surface, enabled, key); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualBall")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickVirtualBallRaw( - JoystickHandle joystick, - int ball, - [NativeTypeName("Sint16")] short xrel, - [NativeTypeName("Sint16")] short yrel - ) => DllImport.SetJoystickVirtualBallRaw(joystick, ball, xrel, yrel); + public static byte SetSurfaceColorKey( + Surface* surface, + [NativeTypeName("bool")] byte enabled, + [NativeTypeName("Uint32")] uint key + ) => DllImport.SetSurfaceColorKey(surface, enabled, key); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] byte down + MaybeBool ISdl.SetSurfaceColorKey( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled, + [NativeTypeName("Uint32")] uint key + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).SetSurfaceColorKey(__dsl_surface, (byte)enabled, key); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetSurfaceColorKey( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled, + [NativeTypeName("Uint32")] uint key + ) => DllImport.SetSurfaceColorKey(surface, enabled, key); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b ) => ( - (delegate* unmanaged)( - _slots[721] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[937] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[721] = nativeContext.LoadFunction( - "SDL_SetJoystickVirtualButton", - "SDL3" - ) + : _slots[937] = nativeContext.LoadFunction("SDL_SetSurfaceColorMod", "SDL3") ) - )(joystick, button, down); + )(surface, r, g, b); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] byte down - ) => DllImport.SetJoystickVirtualButton(joystick, button, down); + public static byte SetSurfaceColorMod( + Surface* surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.SetSurfaceColorMod(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] MaybeBool down - ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualButton(joystick, button, (byte)down); + MaybeBool ISdl.SetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool)(byte)((ISdl)this).SetSurfaceColorMod(__dsl_surface, r, g, b); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualButton")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickVirtualButton( - JoystickHandle joystick, - int button, - [NativeTypeName("bool")] MaybeBool down - ) => DllImport.SetJoystickVirtualButton(joystick, button, down); + public static MaybeBool SetSurfaceColorMod( + Ref surface, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.SetSurfaceColorMod(surface, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickVirtualHat( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => (MaybeBool)(byte)((ISdl)this).SetJoystickVirtualHatRaw(joystick, hat, value); + byte ISdl.SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => + ( + (delegate* unmanaged)( + _slots[938] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[938] = nativeContext.LoadFunction("SDL_SetSurfaceColorspace", "SDL3") + ) + )(surface, colorspace); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickVirtualHat( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => DllImport.SetJoystickVirtualHat(joystick, hat, value); + public static byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => + DllImport.SetSurfaceColorspace(surface, colorspace); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickVirtualHatRaw( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => - ( - (delegate* unmanaged)( - _slots[722] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[722] = nativeContext.LoadFunction("SDL_SetJoystickVirtualHat", "SDL3") - ) - )(joystick, hat, value); + MaybeBool ISdl.SetSurfaceColorspace(Ref surface, Colorspace colorspace) + { + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).SetSurfaceColorspace(__dsl_surface, colorspace); + } + } [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualHat")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickVirtualHatRaw( - JoystickHandle joystick, - int hat, - [NativeTypeName("Uint8")] byte value - ) => DllImport.SetJoystickVirtualHatRaw(joystick, hat, value); + public static MaybeBool SetSurfaceColorspace( + Ref surface, + Colorspace colorspace + ) => DllImport.SetSurfaceColorspace(surface, colorspace); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] byte down, - float x, - float y, - float pressure - ) => + byte ISdl.SetSurfacePalette(Surface* surface, Palette* palette) => ( - (delegate* unmanaged)( - _slots[723] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[939] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[723] = nativeContext.LoadFunction( - "SDL_SetJoystickVirtualTouchpad", - "SDL3" - ) + : _slots[939] = nativeContext.LoadFunction("SDL_SetSurfacePalette", "SDL3") ) - )(joystick, touchpad, finger, down, x, y, pressure); + )(surface, palette); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] byte down, - float x, - float y, - float pressure - ) => DllImport.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + public static byte SetSurfacePalette(Surface* surface, Palette* palette) => + DllImport.SetSurfacePalette(surface, palette); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] MaybeBool down, - float x, - float y, - float pressure - ) => - (MaybeBool) - (byte) - ((ISdl)this).SetJoystickVirtualTouchpad( - joystick, - touchpad, - finger, - (byte)down, - x, - y, - pressure - ); + MaybeBool ISdl.SetSurfacePalette(Ref surface, Ref palette) + { + fixed (Palette* __dsl_palette = palette) + fixed (Surface* __dsl_surface = surface) + { + return (MaybeBool) + (byte)((ISdl)this).SetSurfacePalette(__dsl_surface, __dsl_palette); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetJoystickVirtualTouchpad")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetJoystickVirtualTouchpad( - JoystickHandle joystick, - int touchpad, - int finger, - [NativeTypeName("bool")] MaybeBool down, - float x, - float y, - float pressure - ) => DllImport.SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + public static MaybeBool SetSurfacePalette(Ref surface, Ref palette) => + DllImport.SetSurfacePalette(surface, palette); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - void* userdata - ) => + byte ISdl.SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => ( - (delegate* unmanaged)( - _slots[724] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[940] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[724] = nativeContext.LoadFunction("SDL_SetLogOutputFunction", "SDL3") + : _slots[940] = nativeContext.LoadFunction("SDL_SetSurfaceRLE", "SDL3") ) - )(callback, userdata); + )(surface, enabled); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - void* userdata - ) => DllImport.SetLogOutputFunction(callback, userdata); + public static byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => + DllImport.SetSurfaceRLE(surface, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - Ref userdata + MaybeBool ISdl.SetSurfaceRLE( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled ) { - fixed (void* __dsl_userdata = userdata) + fixed (Surface* __dsl_surface = surface) { - ((ISdl)this).SetLogOutputFunction(callback, __dsl_userdata); + return (MaybeBool)(byte)((ISdl)this).SetSurfaceRLE(__dsl_surface, (byte)enabled); } } + [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogOutputFunction")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetLogOutputFunction( - [NativeTypeName("SDL_LogOutputFunction")] LogOutputFunction callback, - Ref userdata - ) => DllImport.SetLogOutputFunction(callback, userdata); + public static MaybeBool SetSurfaceRLE( + Ref surface, + [NativeTypeName("bool")] MaybeBool enabled + ) => DllImport.SetSurfaceRLE(surface, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetLogPriorities(LogPriority priority) => + byte ISdl.SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int cursor + ) => ( - (delegate* unmanaged)( - _slots[725] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[941] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[725] = nativeContext.LoadFunction("SDL_SetLogPriorities", "SDL3") + : _slots[941] = nativeContext.LoadFunction("SDL_SetTextInputArea", "SDL3") ) - )(priority); + )(window, rect, cursor); - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorities")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetLogPriorities(LogPriority priority) => - DllImport.SetLogPriorities(priority); + public static byte SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect, + int cursor + ) => DllImport.SetTextInputArea(window, rect, cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetLogPriority(int category, LogPriority priority) => - ( - (delegate* unmanaged)( - _slots[726] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[726] = nativeContext.LoadFunction("SDL_SetLogPriority", "SDL3") - ) - )(category, priority); + MaybeBool ISdl.SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect, + int cursor + ) + { + fixed (Rect* __dsl_rect = rect) + { + return (MaybeBool)(byte)((ISdl)this).SetTextInputArea(window, __dsl_rect, cursor); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriority")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetLogPriority(int category, LogPriority priority) => - DllImport.SetLogPriority(category, priority); + public static MaybeBool SetTextInputArea( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect, + int cursor + ) => DllImport.SetTextInputArea(window, rect, cursor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] sbyte* prefix - ) => + byte ISdl.SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => ( - (delegate* unmanaged)( - _slots[727] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[942] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[727] = nativeContext.LoadFunction("SDL_SetLogPriorityPrefix", "SDL3") + : _slots[942] = nativeContext.LoadFunction("SDL_SetTextureAlphaMod", "SDL3") ) - )(priority, prefix); + )(texture, alpha); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] sbyte* prefix - ) => DllImport.SetLogPriorityPrefix(priority, prefix); + public static byte SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => + DllImport.SetTextureAlphaMod(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] Ref prefix + MaybeBool ISdl.SetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8")] byte alpha ) { - fixed (sbyte* __dsl_prefix = prefix) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).SetLogPriorityPrefix(priority, __dsl_prefix); + return (MaybeBool)(byte)((ISdl)this).SetTextureAlphaMod(__dsl_texture, alpha); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetLogPriorityPrefix")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetLogPriorityPrefix( - LogPriority priority, - [NativeTypeName("const char *")] Ref prefix - ) => DllImport.SetLogPriorityPrefix(priority, prefix); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => - ( - (delegate* unmanaged)( - _slots[728] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[728] = nativeContext.LoadFunction("SDL_SetModState", "SDL3") - ) - )(modstate); - - [NativeFunction("SDL3", EntryPoint = "SDL_SetModState")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SetModState([NativeTypeName("SDL_Keymod")] ushort modstate) => - DllImport.SetModState(modstate); + public static MaybeBool SetTextureAlphaMod( + Ref texture, + [NativeTypeName("Uint8")] byte alpha + ) => DllImport.SetTextureAlphaMod(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long value - ) => + byte ISdl.SetTextureAlphaModFloat(Texture* texture, float alpha) => ( - (delegate* unmanaged)( - _slots[729] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[943] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[729] = nativeContext.LoadFunction("SDL_SetNumberProperty", "SDL3") + : _slots[943] = nativeContext.LoadFunction( + "SDL_SetTextureAlphaModFloat", + "SDL3" + ) ) - )(props, name, value); + )(texture, alpha); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("Sint64")] long value - ) => DllImport.SetNumberProperty(props, name, value); + public static byte SetTextureAlphaModFloat(Texture* texture, float alpha) => + DllImport.SetTextureAlphaModFloat(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long value - ) + MaybeBool ISdl.SetTextureAlphaModFloat(Ref texture, float alpha) { - fixed (sbyte* __dsl_name = name) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).SetNumberProperty(props, __dsl_name, value); + return (MaybeBool) + (byte)((ISdl)this).SetTextureAlphaModFloat(__dsl_texture, alpha); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetNumberProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetNumberProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("Sint64")] long value - ) => DllImport.SetNumberProperty(props, name, value); + public static MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) => + DllImport.SetTextureAlphaModFloat(texture, alpha); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetPaletteColors( - Palette* palette, - [NativeTypeName("const SDL_Color *")] Color* colors, - int firstcolor, - int ncolors + byte ISdl.SetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode ) => ( - (delegate* unmanaged)( - _slots[730] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[944] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[730] = nativeContext.LoadFunction("SDL_SetPaletteColors", "SDL3") + : _slots[944] = nativeContext.LoadFunction("SDL_SetTextureBlendMode", "SDL3") ) - )(palette, colors, firstcolor, ncolors); + )(texture, blendMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetPaletteColors( - Palette* palette, - [NativeTypeName("const SDL_Color *")] Color* colors, - int firstcolor, - int ncolors - ) => DllImport.SetPaletteColors(palette, colors, firstcolor, ncolors); + public static byte SetTextureBlendMode( + Texture* texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetTextureBlendMode(texture, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetPaletteColors( - Ref palette, - [NativeTypeName("const SDL_Color *")] Ref colors, - int firstcolor, - int ncolors + MaybeBool ISdl.SetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode ) { - fixed (Color* __dsl_colors = colors) - fixed (Palette* __dsl_palette = palette) + fixed (Texture* __dsl_texture = texture) { return (MaybeBool) - (byte) - ((ISdl)this).SetPaletteColors(__dsl_palette, __dsl_colors, firstcolor, ncolors); + (byte)((ISdl)this).SetTextureBlendMode(__dsl_texture, blendMode); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPaletteColors")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetPaletteColors( - Ref palette, - [NativeTypeName("const SDL_Color *")] Ref colors, - int firstcolor, - int ncolors - ) => DllImport.SetPaletteColors(palette, colors, firstcolor, ncolors); + public static MaybeBool SetTextureBlendMode( + Ref texture, + [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + ) => DllImport.SetTextureBlendMode(texture, blendMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value + byte ISdl.SetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b ) => ( - (delegate* unmanaged)( - _slots[731] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[945] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[731] = nativeContext.LoadFunction("SDL_SetPointerProperty", "SDL3") + : _slots[945] = nativeContext.LoadFunction("SDL_SetTextureColorMod", "SDL3") ) - )(props, name, value); + )(texture, r, g, b); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value - ) => DllImport.SetPointerProperty(props, name, value); + public static byte SetTextureColorMod( + Texture* texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.SetTextureColorMod(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value + MaybeBool ISdl.SetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b ) { - fixed (void* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool) - (byte)((ISdl)this).SetPointerProperty(props, __dsl_name, __dsl_value); + return (MaybeBool)(byte)((ISdl)this).SetTextureColorMod(__dsl_texture, r, g, b); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetPointerProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value - ) => DllImport.SetPointerProperty(props, name, value); + public static MaybeBool SetTextureColorMod( + Ref texture, + [NativeTypeName("Uint8")] byte r, + [NativeTypeName("Uint8")] byte g, + [NativeTypeName("Uint8")] byte b + ) => DllImport.SetTextureColorMod(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - void* userdata - ) => + byte ISdl.SetTextureColorModFloat(Texture* texture, float r, float g, float b) => ( - (delegate* unmanaged)( - _slots[732] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[946] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[732] = nativeContext.LoadFunction( - "SDL_SetPointerPropertyWithCleanup", + : _slots[946] = nativeContext.LoadFunction( + "SDL_SetTextureColorModFloat", "SDL3" ) ) - )(props, name, value, cleanup, userdata); + )(texture, r, g, b); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - void* value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - void* userdata - ) => DllImport.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + public static byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => + DllImport.SetTextureColorModFloat(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - Ref userdata - ) + MaybeBool ISdl.SetTextureColorModFloat(Ref texture, float r, float g, float b) { - fixed (void* __dsl_userdata = userdata) - fixed (void* __dsl_value = value) - fixed (sbyte* __dsl_name = name) + fixed (Texture* __dsl_texture = texture) { return (MaybeBool) - (byte) - ((ISdl)this).SetPointerPropertyWithCleanup( - props, - __dsl_name, - __dsl_value, - cleanup, - __dsl_userdata - ); + (byte)((ISdl)this).SetTextureColorModFloat(__dsl_texture, r, g, b); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPointerPropertyWithCleanup")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetPointerPropertyWithCleanup( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - Ref value, - [NativeTypeName("SDL_CleanupPropertyCallback")] CleanupPropertyCallback cleanup, - Ref userdata - ) => DllImport.SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); + public static MaybeBool SetTextureColorModFloat( + Ref texture, + float r, + float g, + float b + ) => DllImport.SetTextureColorModFloat(texture, r, g, b); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => + byte ISdl.SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => ( - (delegate* unmanaged)( - _slots[733] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[947] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[733] = nativeContext.LoadFunction( - "SDL_SetPrimarySelectionText", - "SDL3" - ) + : _slots[947] = nativeContext.LoadFunction("SDL_SetTextureScaleMode", "SDL3") ) - )(text); + )(texture, scaleMode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetPrimarySelectionText([NativeTypeName("const char *")] sbyte* text) => - DllImport.SetPrimarySelectionText(text); + public static byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => + DllImport.SetTextureScaleMode(texture, scaleMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetPrimarySelectionText([NativeTypeName("const char *")] Ref text) + MaybeBool ISdl.SetTextureScaleMode(Ref texture, ScaleMode scaleMode) { - fixed (sbyte* __dsl_text = text) + fixed (Texture* __dsl_texture = texture) { - return (MaybeBool)(byte)((ISdl)this).SetPrimarySelectionText(__dsl_text); + return (MaybeBool) + (byte)((ISdl)this).SetTextureScaleMode(__dsl_texture, scaleMode); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetPrimarySelectionText")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetPrimarySelectionText( - [NativeTypeName("const char *")] Ref text - ) => DllImport.SetPrimarySelectionText(text); + public static MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) => + DllImport.SetTextureScaleMode(texture, scaleMode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect + byte ISdl.SetTLS( + [NativeTypeName("SDL_TLSID *")] AtomicInt* id, + [NativeTypeName("const void *")] void* value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor ) => ( - (delegate* unmanaged)( - _slots[734] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[948] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[734] = nativeContext.LoadFunction("SDL_SetRenderClipRect", "SDL3") + : _slots[948] = nativeContext.LoadFunction("SDL_SetTLS", "SDL3") ) - )(renderer, rect); + )(id, value, destructor); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => DllImport.SetRenderClipRect(renderer, rect); + public static byte SetTLS( + [NativeTypeName("SDL_TLSID *")] AtomicInt* id, + [NativeTypeName("const void *")] void* value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) => DllImport.SetTLS(id, value, destructor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect + MaybeBool ISdl.SetTLS( + [NativeTypeName("SDL_TLSID *")] Ref id, + [NativeTypeName("const void *")] Ref value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor ) { - fixed (Rect* __dsl_rect = rect) + fixed (void* __dsl_value = value) + fixed (AtomicInt* __dsl_id = id) { - return (MaybeBool)(byte)((ISdl)this).SetRenderClipRect(renderer, __dsl_rect); + return (MaybeBool)(byte)((ISdl)this).SetTLS(__dsl_id, __dsl_value, destructor); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderClipRect( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => DllImport.SetRenderClipRect(renderer, rect); + public static MaybeBool SetTLS( + [NativeTypeName("SDL_TLSID *")] Ref id, + [NativeTypeName("const void *")] Ref value, + [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + ) => DllImport.SetTLS(id, value, destructor); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderColorScale(RendererHandle renderer, float scale) => - (MaybeBool)(byte)((ISdl)this).SetRenderColorScaleRaw(renderer, scale); + byte ISdl.SetWindowAlwaysOnTop(WindowHandle window, [NativeTypeName("bool")] byte on_top) => + ( + (delegate* unmanaged)( + _slots[949] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[949] = nativeContext.LoadFunction("SDL_SetWindowAlwaysOnTop", "SDL3") + ) + )(window, on_top); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderColorScale(RendererHandle renderer, float scale) => - DllImport.SetRenderColorScale(renderer, scale); + public static byte SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] byte on_top + ) => DllImport.SetWindowAlwaysOnTop(window, on_top); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderColorScaleRaw(RendererHandle renderer, float scale) => - ( - (delegate* unmanaged)( - _slots[735] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[735] = nativeContext.LoadFunction("SDL_SetRenderColorScale", "SDL3") - ) - )(renderer, scale); + MaybeBool ISdl.SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool on_top + ) => (MaybeBool)(byte)((ISdl)this).SetWindowAlwaysOnTop(window, (byte)on_top); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderColorScale")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderColorScaleRaw(RendererHandle renderer, float scale) => - DllImport.SetRenderColorScaleRaw(renderer, scale); + public static MaybeBool SetWindowAlwaysOnTop( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool on_top + ) => DllImport.SetWindowAlwaysOnTop(window, on_top); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawBlendModeRaw(renderer, blendMode); + MaybeBool ISdl.SetWindowAspectRatio( + WindowHandle window, + float min_aspect, + float max_aspect + ) => + (MaybeBool)(byte)((ISdl)this).SetWindowAspectRatioRaw(window, min_aspect, max_aspect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderDrawBlendMode( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetRenderDrawBlendMode(renderer, blendMode); + public static MaybeBool SetWindowAspectRatio( + WindowHandle window, + float min_aspect, + float max_aspect + ) => DllImport.SetWindowAspectRatio(window, min_aspect, max_aspect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderDrawBlendModeRaw( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => + byte ISdl.SetWindowAspectRatioRaw(WindowHandle window, float min_aspect, float max_aspect) => ( - (delegate* unmanaged)( - _slots[736] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[950] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[736] = nativeContext.LoadFunction("SDL_SetRenderDrawBlendMode", "SDL3") + : _slots[950] = nativeContext.LoadFunction("SDL_SetWindowAspectRatio", "SDL3") ) - )(renderer, blendMode); + )(window, min_aspect, max_aspect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderDrawBlendModeRaw( - RendererHandle renderer, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetRenderDrawBlendModeRaw(renderer, blendMode); + public static byte SetWindowAspectRatioRaw( + WindowHandle window, + float min_aspect, + float max_aspect + ) => DllImport.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawColorRaw(renderer, r, g, b, a); + byte ISdl.SetWindowBordered(WindowHandle window, [NativeTypeName("bool")] byte bordered) => + ( + (delegate* unmanaged)( + _slots[951] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[951] = nativeContext.LoadFunction("SDL_SetWindowBordered", "SDL3") + ) + )(window, bordered); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderDrawColor( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.SetRenderDrawColor(renderer, r, g, b, a); + public static byte SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] byte bordered + ) => DllImport.SetWindowBordered(window, bordered); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderDrawColorFloat( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => (MaybeBool)(byte)((ISdl)this).SetRenderDrawColorFloatRaw(renderer, r, g, b, a); + MaybeBool ISdl.SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool bordered + ) => (MaybeBool)(byte)((ISdl)this).SetWindowBordered(window, (byte)bordered); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderDrawColorFloat( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => DllImport.SetRenderDrawColorFloat(renderer, r, g, b, a); + public static MaybeBool SetWindowBordered( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool bordered + ) => DllImport.SetWindowBordered(window, bordered); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderDrawColorFloatRaw( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => + byte ISdl.SetWindowFocusable(WindowHandle window, [NativeTypeName("bool")] byte focusable) => ( - (delegate* unmanaged)( - _slots[738] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[952] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[738] = nativeContext.LoadFunction( - "SDL_SetRenderDrawColorFloat", - "SDL3" - ) + : _slots[952] = nativeContext.LoadFunction("SDL_SetWindowFocusable", "SDL3") ) - )(renderer, r, g, b, a); + )(window, focusable); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColorFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderDrawColorFloatRaw( - RendererHandle renderer, - float r, - float g, - float b, - float a - ) => DllImport.SetRenderDrawColorFloatRaw(renderer, r, g, b, a); + public static byte SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] byte focusable + ) => DllImport.SetWindowFocusable(window, focusable); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderDrawColorRaw( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => + MaybeBool ISdl.SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool focusable + ) => (MaybeBool)(byte)((ISdl)this).SetWindowFocusable(window, (byte)focusable); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetWindowFocusable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool focusable + ) => DllImport.SetWindowFocusable(window, focusable); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetWindowFullscreen(WindowHandle window, [NativeTypeName("bool")] byte fullscreen) => ( - (delegate* unmanaged)( - _slots[737] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[953] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[737] = nativeContext.LoadFunction("SDL_SetRenderDrawColor", "SDL3") + : _slots[953] = nativeContext.LoadFunction("SDL_SetWindowFullscreen", "SDL3") ) - )(renderer, r, g, b, a); + )(window, fullscreen); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderDrawColor")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderDrawColorRaw( - RendererHandle renderer, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b, - [NativeTypeName("Uint8")] byte a - ) => DllImport.SetRenderDrawColorRaw(renderer, r, g, b, a); + public static byte SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] byte fullscreen + ) => DllImport.SetWindowFullscreen(window, fullscreen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderLogicalPresentation( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => (MaybeBool)(byte)((ISdl)this).SetRenderLogicalPresentationRaw(renderer, w, h, mode); + MaybeBool ISdl.SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool fullscreen + ) => (MaybeBool)(byte)((ISdl)this).SetWindowFullscreen(window, (byte)fullscreen); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderLogicalPresentation( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => DllImport.SetRenderLogicalPresentation(renderer, w, h, mode); + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetWindowFullscreen( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool fullscreen + ) => DllImport.SetWindowFullscreen(window, fullscreen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderLogicalPresentationRaw( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode + byte ISdl.SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode ) => ( - (delegate* unmanaged)( - _slots[739] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[954] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[739] = nativeContext.LoadFunction( - "SDL_SetRenderLogicalPresentation", + : _slots[954] = nativeContext.LoadFunction( + "SDL_SetWindowFullscreenMode", "SDL3" ) ) - )(renderer, w, h, mode); + )(window, mode); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderLogicalPresentation")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderLogicalPresentationRaw( - RendererHandle renderer, - int w, - int h, - RendererLogicalPresentation mode - ) => DllImport.SetRenderLogicalPresentationRaw(renderer, w, h, mode); + public static byte SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode + ) => DllImport.SetWindowFullscreenMode(window, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderScale(RendererHandle renderer, float scaleX, float scaleY) => - (MaybeBool)(byte)((ISdl)this).SetRenderScaleRaw(renderer, scaleX, scaleY); + MaybeBool ISdl.SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] Ref mode + ) + { + fixed (DisplayMode* __dsl_mode = mode) + { + return (MaybeBool)(byte)((ISdl)this).SetWindowFullscreenMode(window, __dsl_mode); + } + } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderScale( - RendererHandle renderer, - float scaleX, - float scaleY - ) => DllImport.SetRenderScale(renderer, scaleX, scaleY); + public static MaybeBool SetWindowFullscreenMode( + WindowHandle window, + [NativeTypeName("const SDL_DisplayMode *")] Ref mode + ) => DllImport.SetWindowFullscreenMode(window, mode); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => + byte ISdl.SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + void* callback_data + ) => ( - (delegate* unmanaged)( - _slots[740] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[955] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[740] = nativeContext.LoadFunction("SDL_SetRenderScale", "SDL3") + : _slots[955] = nativeContext.LoadFunction("SDL_SetWindowHitTest", "SDL3") ) - )(renderer, scaleX, scaleY); + )(window, callback, callback_data); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderScale")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderScaleRaw(RendererHandle renderer, float scaleX, float scaleY) => - DllImport.SetRenderScaleRaw(renderer, scaleX, scaleY); + public static byte SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + void* callback_data + ) => DllImport.SetWindowHitTest(window, callback, callback_data); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderTarget(RendererHandle renderer, Texture* texture) => + MaybeBool ISdl.SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + Ref callback_data + ) + { + fixed (void* __dsl_callback_data = callback_data) + { + return (MaybeBool) + (byte)((ISdl)this).SetWindowHitTest(window, callback, __dsl_callback_data); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetWindowHitTest( + WindowHandle window, + [NativeTypeName("SDL_HitTest")] HitTest callback, + Ref callback_data + ) => DllImport.SetWindowHitTest(window, callback, callback_data); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetWindowIcon(WindowHandle window, Surface* icon) => ( - (delegate* unmanaged)( - _slots[741] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[956] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[741] = nativeContext.LoadFunction("SDL_SetRenderTarget", "SDL3") + : _slots[956] = nativeContext.LoadFunction("SDL_SetWindowIcon", "SDL3") ) - )(renderer, texture); + )(window, icon); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderTarget(RendererHandle renderer, Texture* texture) => - DllImport.SetRenderTarget(renderer, texture); + public static byte SetWindowIcon(WindowHandle window, Surface* icon) => + DllImport.SetWindowIcon(window, icon); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderTarget(RendererHandle renderer, Ref texture) + MaybeBool ISdl.SetWindowIcon(WindowHandle window, Ref icon) { - fixed (Texture* __dsl_texture = texture) + fixed (Surface* __dsl_icon = icon) { - return (MaybeBool)(byte)((ISdl)this).SetRenderTarget(renderer, __dsl_texture); + return (MaybeBool)(byte)((ISdl)this).SetWindowIcon(window, __dsl_icon); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderTarget")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderTarget(RendererHandle renderer, Ref texture) => - DllImport.SetRenderTarget(renderer, texture); + public static MaybeBool SetWindowIcon(WindowHandle window, Ref icon) => + DllImport.SetWindowIcon(window, icon); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => + byte ISdl.SetWindowKeyboardGrab(WindowHandle window, [NativeTypeName("bool")] byte grabbed) => ( - (delegate* unmanaged)( - _slots[742] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[957] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[742] = nativeContext.LoadFunction("SDL_SetRenderViewport", "SDL3") + : _slots[957] = nativeContext.LoadFunction("SDL_SetWindowKeyboardGrab", "SDL3") ) - )(renderer, rect); + )(window, grabbed); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => DllImport.SetRenderViewport(renderer, rect); + public static byte SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => DllImport.SetWindowKeyboardGrab(window, grabbed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)((ISdl)this).SetRenderViewport(renderer, __dsl_rect); - } - } + MaybeBool ISdl.SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => (MaybeBool)(byte)((ISdl)this).SetWindowKeyboardGrab(window, (byte)grabbed); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderViewport")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderViewport( - RendererHandle renderer, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => DllImport.SetRenderViewport(renderer, rect); + public static MaybeBool SetWindowKeyboardGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => DllImport.SetWindowKeyboardGrab(window, grabbed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetRenderVSync(RendererHandle renderer, int vsync) => - (MaybeBool)(byte)((ISdl)this).SetRenderVSyncRaw(renderer, vsync); + MaybeBool ISdl.SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => + (MaybeBool)(byte)((ISdl)this).SetWindowMaximumSizeRaw(window, max_w, max_h); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetRenderVSync(RendererHandle renderer, int vsync) => - DllImport.SetRenderVSync(renderer, vsync); + public static MaybeBool SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => + DllImport.SetWindowMaximumSize(window, max_w, max_h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetRenderVSyncRaw(RendererHandle renderer, int vsync) => + byte ISdl.SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => ( - (delegate* unmanaged)( - _slots[743] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[958] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[743] = nativeContext.LoadFunction("SDL_SetRenderVSync", "SDL3") + : _slots[958] = nativeContext.LoadFunction("SDL_SetWindowMaximumSize", "SDL3") ) - )(renderer, vsync); + )(window, max_w, max_h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetRenderVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetRenderVSyncRaw(RendererHandle renderer, int vsync) => - DllImport.SetRenderVSyncRaw(renderer, vsync); + public static byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => + DllImport.SetWindowMaximumSizeRaw(window, max_w, max_h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetScancodeName(Scancode scancode, [NativeTypeName("const char *")] sbyte* name) => - ( - (delegate* unmanaged)( - _slots[744] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[744] = nativeContext.LoadFunction("SDL_SetScancodeName", "SDL3") - ) - )(scancode, name); + MaybeBool ISdl.SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => + (MaybeBool)(byte)((ISdl)this).SetWindowMinimumSizeRaw(window, min_w, min_h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] sbyte* name - ) => DllImport.SetScancodeName(scancode, name); + public static MaybeBool SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => + DllImport.SetWindowMinimumSize(window, min_w, min_h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] Ref name - ) - { - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool)(byte)((ISdl)this).SetScancodeName(scancode, __dsl_name); - } - } + byte ISdl.SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => + ( + (delegate* unmanaged)( + _slots[959] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[959] = nativeContext.LoadFunction("SDL_SetWindowMinimumSize", "SDL3") + ) + )(window, min_w, min_h); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetScancodeName")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetScancodeName( - Scancode scancode, - [NativeTypeName("const char *")] Ref name - ) => DllImport.SetScancodeName(scancode, name); + public static byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => + DllImport.SetWindowMinimumSizeRaw(window, min_w, min_h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => + byte ISdl.SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => ( - (delegate* unmanaged)( - _slots[745] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[960] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[745] = nativeContext.LoadFunction("SDL_SetStringProperty", "SDL3") + : _slots[960] = nativeContext.LoadFunction("SDL_SetWindowModal", "SDL3") ) - )(props, name, value); + )(window, modal); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] sbyte* name, - [NativeTypeName("const char *")] sbyte* value - ) => DllImport.SetStringProperty(props, name, value); + public static byte SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => + DllImport.SetWindowModal(window, modal); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) - { - fixed (sbyte* __dsl_value = value) - fixed (sbyte* __dsl_name = name) - { - return (MaybeBool) - (byte)((ISdl)this).SetStringProperty(props, __dsl_name, __dsl_value); - } - } + MaybeBool ISdl.SetWindowModal( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool modal + ) => (MaybeBool)(byte)((ISdl)this).SetWindowModal(window, (byte)modal); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetStringProperty")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetStringProperty( - [NativeTypeName("SDL_PropertiesID")] uint props, - [NativeTypeName("const char *")] Ref name, - [NativeTypeName("const char *")] Ref value - ) => DllImport.SetStringProperty(props, name, value); + public static MaybeBool SetWindowModal( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool modal + ) => DllImport.SetWindowModal(window, modal); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => + byte ISdl.SetWindowMouseGrab(WindowHandle window, [NativeTypeName("bool")] byte grabbed) => ( - (delegate* unmanaged)( - _slots[746] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[961] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[746] = nativeContext.LoadFunction("SDL_SetSurfaceAlphaMod", "SDL3") + : _slots[961] = nativeContext.LoadFunction("SDL_SetWindowMouseGrab", "SDL3") ) - )(surface, alpha); + )(window, grabbed); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceAlphaMod(Surface* surface, [NativeTypeName("Uint8")] byte alpha) => - DllImport.SetSurfaceAlphaMod(surface, alpha); + public static byte SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] byte grabbed + ) => DllImport.SetWindowMouseGrab(window, grabbed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8")] byte alpha - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).SetSurfaceAlphaMod(__dsl_surface, alpha); - } - } + MaybeBool ISdl.SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => (MaybeBool)(byte)((ISdl)this).SetWindowMouseGrab(window, (byte)grabbed); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceAlphaMod( - Ref surface, - [NativeTypeName("Uint8")] byte alpha - ) => DllImport.SetSurfaceAlphaMod(surface, alpha); + public static MaybeBool SetWindowMouseGrab( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool grabbed + ) => DllImport.SetWindowMouseGrab(window, grabbed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + byte ISdl.SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect ) => ( - (delegate* unmanaged)( - _slots[747] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[962] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[747] = nativeContext.LoadFunction("SDL_SetSurfaceBlendMode", "SDL3") + : _slots[962] = nativeContext.LoadFunction("SDL_SetWindowMouseRect", "SDL3") ) - )(surface, blendMode); + )(window, rect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceBlendMode( - Surface* surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetSurfaceBlendMode(surface, blendMode); + public static byte SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Rect* rect + ) => DllImport.SetWindowMouseRect(window, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + MaybeBool ISdl.SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect ) { - fixed (Surface* __dsl_surface = surface) + fixed (Rect* __dsl_rect = rect) { - return (MaybeBool) - (byte)((ISdl)this).SetSurfaceBlendMode(__dsl_surface, blendMode); + return (MaybeBool)(byte)((ISdl)this).SetWindowMouseRect(window, __dsl_rect); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceBlendMode( - Ref surface, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetSurfaceBlendMode(surface, blendMode); + public static MaybeBool SetWindowMouseRect( + WindowHandle window, + [NativeTypeName("const SDL_Rect *")] Ref rect + ) => DllImport.SetWindowMouseRect(window, rect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceClipRect( - Surface* surface, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => + MaybeBool ISdl.SetWindowOpacity(WindowHandle window, float opacity) => + (MaybeBool)(byte)((ISdl)this).SetWindowOpacityRaw(window, opacity); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => + DllImport.SetWindowOpacity(window, opacity); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetWindowOpacityRaw(WindowHandle window, float opacity) => ( - (delegate* unmanaged)( - _slots[748] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[963] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[748] = nativeContext.LoadFunction("SDL_SetSurfaceClipRect", "SDL3") + : _slots[963] = nativeContext.LoadFunction("SDL_SetWindowOpacity", "SDL3") ) - )(surface, rect); + )(window, opacity); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceClipRect( - Surface* surface, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => DllImport.SetSurfaceClipRect(surface, rect); + public static byte SetWindowOpacityRaw(WindowHandle window, float opacity) => + DllImport.SetWindowOpacityRaw(window, opacity); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceClipRect( - Ref surface, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).SetSurfaceClipRect(__dsl_surface, __dsl_rect); - } - } + MaybeBool ISdl.SetWindowParent(WindowHandle window, WindowHandle parent) => + (MaybeBool)(byte)((ISdl)this).SetWindowParentRaw(window, parent); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceClipRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceClipRect( - Ref surface, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => DllImport.SetSurfaceClipRect(surface, rect); + public static MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => + DllImport.SetWindowParent(window, parent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceColorKey( - Surface* surface, - [NativeTypeName("bool")] byte enabled, - [NativeTypeName("Uint32")] uint key - ) => + byte ISdl.SetWindowParentRaw(WindowHandle window, WindowHandle parent) => ( - (delegate* unmanaged)( - _slots[749] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[964] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[749] = nativeContext.LoadFunction("SDL_SetSurfaceColorKey", "SDL3") + : _slots[964] = nativeContext.LoadFunction("SDL_SetWindowParent", "SDL3") ) - )(surface, enabled, key); + )(window, parent); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceColorKey( - Surface* surface, - [NativeTypeName("bool")] byte enabled, - [NativeTypeName("Uint32")] uint key - ) => DllImport.SetSurfaceColorKey(surface, enabled, key); + public static byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => + DllImport.SetWindowParentRaw(window, parent); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceColorKey( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled, - [NativeTypeName("Uint32")] uint key - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).SetSurfaceColorKey(__dsl_surface, (byte)enabled, key); - } - } + MaybeBool ISdl.SetWindowPosition(WindowHandle window, int x, int y) => + (MaybeBool)(byte)((ISdl)this).SetWindowPositionRaw(window, x, y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorKey")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceColorKey( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled, - [NativeTypeName("Uint32")] uint key - ) => DllImport.SetSurfaceColorKey(surface, enabled, key); + public static MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => + DllImport.SetWindowPosition(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => + byte ISdl.SetWindowPositionRaw(WindowHandle window, int x, int y) => ( - (delegate* unmanaged)( - _slots[750] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[965] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[750] = nativeContext.LoadFunction("SDL_SetSurfaceColorMod", "SDL3") + : _slots[965] = nativeContext.LoadFunction("SDL_SetWindowPosition", "SDL3") ) - )(surface, r, g, b); + )(window, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceColorMod( - Surface* surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.SetSurfaceColorMod(surface, r, g, b); + public static byte SetWindowPositionRaw(WindowHandle window, int x, int y) => + DllImport.SetWindowPositionRaw(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).SetSurfaceColorMod(__dsl_surface, r, g, b); - } - } + byte ISdl.SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] byte enabled + ) => + ( + (delegate* unmanaged)( + _slots[966] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[966] = nativeContext.LoadFunction( + "SDL_SetWindowRelativeMouseMode", + "SDL3" + ) + ) + )(window, enabled); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] byte enabled + ) => DllImport.SetWindowRelativeMouseMode(window, enabled); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool enabled + ) => (MaybeBool)(byte)((ISdl)this).SetWindowRelativeMouseMode(window, (byte)enabled); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceColorMod( - Ref surface, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.SetSurfaceColorMod(surface, r, g, b); + public static MaybeBool SetWindowRelativeMouseMode( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool enabled + ) => DllImport.SetWindowRelativeMouseMode(window, enabled); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => + byte ISdl.SetWindowResizable(WindowHandle window, [NativeTypeName("bool")] byte resizable) => ( - (delegate* unmanaged)( - _slots[751] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[967] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[751] = nativeContext.LoadFunction("SDL_SetSurfaceColorspace", "SDL3") + : _slots[967] = nativeContext.LoadFunction("SDL_SetWindowResizable", "SDL3") ) - )(surface, colorspace); + )(window, resizable); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceColorspace(Surface* surface, Colorspace colorspace) => - DllImport.SetSurfaceColorspace(surface, colorspace); + public static byte SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] byte resizable + ) => DllImport.SetWindowResizable(window, resizable); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceColorspace(Ref surface, Colorspace colorspace) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool) - (byte)((ISdl)this).SetSurfaceColorspace(__dsl_surface, colorspace); - } - } + MaybeBool ISdl.SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool resizable + ) => (MaybeBool)(byte)((ISdl)this).SetWindowResizable(window, (byte)resizable); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceColorspace")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceColorspace( - Ref surface, - Colorspace colorspace - ) => DllImport.SetSurfaceColorspace(surface, colorspace); + public static MaybeBool SetWindowResizable( + WindowHandle window, + [NativeTypeName("bool")] MaybeBool resizable + ) => DllImport.SetWindowResizable(window, resizable); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfacePalette(Surface* surface, Palette* palette) => + byte ISdl.SetWindowShape(WindowHandle window, Surface* shape) => ( - (delegate* unmanaged)( - _slots[752] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[968] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[752] = nativeContext.LoadFunction("SDL_SetSurfacePalette", "SDL3") + : _slots[968] = nativeContext.LoadFunction("SDL_SetWindowShape", "SDL3") ) - )(surface, palette); + )(window, shape); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfacePalette(Surface* surface, Palette* palette) => - DllImport.SetSurfacePalette(surface, palette); + public static byte SetWindowShape(WindowHandle window, Surface* shape) => + DllImport.SetWindowShape(window, shape); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfacePalette(Ref surface, Ref palette) + MaybeBool ISdl.SetWindowShape(WindowHandle window, Ref shape) { - fixed (Palette* __dsl_palette = palette) - fixed (Surface* __dsl_surface = surface) + fixed (Surface* __dsl_shape = shape) { - return (MaybeBool) - (byte)((ISdl)this).SetSurfacePalette(__dsl_surface, __dsl_palette); + return (MaybeBool)(byte)((ISdl)this).SetWindowShape(window, __dsl_shape); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfacePalette")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfacePalette(Ref surface, Ref palette) => - DllImport.SetSurfacePalette(surface, palette); + public static MaybeBool SetWindowShape(WindowHandle window, Ref shape) => + DllImport.SetWindowShape(window, shape); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => + MaybeBool ISdl.SetWindowSize(WindowHandle window, int w, int h) => + (MaybeBool)(byte)((ISdl)this).SetWindowSizeRaw(window, w, h); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool SetWindowSize(WindowHandle window, int w, int h) => + DllImport.SetWindowSize(window, w, h); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetWindowSizeRaw(WindowHandle window, int w, int h) => ( - (delegate* unmanaged)( - _slots[753] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[969] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[753] = nativeContext.LoadFunction("SDL_SetSurfaceRLE", "SDL3") + : _slots[969] = nativeContext.LoadFunction("SDL_SetWindowSize", "SDL3") ) - )(surface, enabled); + )(window, w, h); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetSurfaceRLE(Surface* surface, [NativeTypeName("bool")] byte enabled) => - DllImport.SetSurfaceRLE(surface, enabled); + public static byte SetWindowSizeRaw(WindowHandle window, int w, int h) => + DllImport.SetWindowSizeRaw(window, w, h); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetSurfaceRLE( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled - ) - { - fixed (Surface* __dsl_surface = surface) - { - return (MaybeBool)(byte)((ISdl)this).SetSurfaceRLE(__dsl_surface, (byte)enabled); - } - } + MaybeBool ISdl.SetWindowSurfaceVSync(WindowHandle window, int vsync) => + (MaybeBool)(byte)((ISdl)this).SetWindowSurfaceVSyncRaw(window, vsync); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetSurfaceRLE")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetSurfaceRLE( - Ref surface, - [NativeTypeName("bool")] MaybeBool enabled - ) => DllImport.SetSurfaceRLE(surface, enabled); + public static MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => + DllImport.SetWindowSurfaceVSync(window, vsync); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextInputArea( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int cursor - ) => + byte ISdl.SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => ( - (delegate* unmanaged)( - _slots[754] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[970] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[754] = nativeContext.LoadFunction("SDL_SetTextInputArea", "SDL3") + : _slots[970] = nativeContext.LoadFunction("SDL_SetWindowSurfaceVSync", "SDL3") ) - )(window, rect, cursor); + )(window, vsync); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextInputArea( + public static byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => + DllImport.SetWindowSurfaceVSyncRaw(window, vsync); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.SetWindowTitle(WindowHandle window, [NativeTypeName("const char *")] sbyte* title) => + ( + (delegate* unmanaged)( + _slots[971] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[971] = nativeContext.LoadFunction("SDL_SetWindowTitle", "SDL3") + ) + )(window, title); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte SetWindowTitle( WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect, - int cursor - ) => DllImport.SetTextInputArea(window, rect, cursor); + [NativeTypeName("const char *")] sbyte* title + ) => DllImport.SetWindowTitle(window, title); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextInputArea( + MaybeBool ISdl.SetWindowTitle( WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect, - int cursor + [NativeTypeName("const char *")] Ref title ) { - fixed (Rect* __dsl_rect = rect) + fixed (sbyte* __dsl_title = title) { - return (MaybeBool)(byte)((ISdl)this).SetTextInputArea(window, __dsl_rect, cursor); + return (MaybeBool)(byte)((ISdl)this).SetWindowTitle(window, __dsl_title); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextInputArea")] + [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextInputArea( + public static MaybeBool SetWindowTitle( WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect, - int cursor - ) => DllImport.SetTextInputArea(window, rect, cursor); + [NativeTypeName("const char *")] Ref title + ) => DllImport.SetWindowTitle(window, title); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => + byte ISdl.ShouldInit(InitState* state) => ( - (delegate* unmanaged)( - _slots[755] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[972] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[755] = nativeContext.LoadFunction("SDL_SetTextureAlphaMod", "SDL3") + : _slots[972] = nativeContext.LoadFunction("SDL_ShouldInit", "SDL3") ) - )(texture, alpha); + )(state); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureAlphaMod(Texture* texture, [NativeTypeName("Uint8")] byte alpha) => - DllImport.SetTextureAlphaMod(texture, alpha); + public static byte ShouldInit(InitState* state) => DllImport.ShouldInit(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8")] byte alpha - ) + MaybeBool ISdl.ShouldInit(Ref state) { - fixed (Texture* __dsl_texture = texture) + fixed (InitState* __dsl_state = state) { - return (MaybeBool)(byte)((ISdl)this).SetTextureAlphaMod(__dsl_texture, alpha); + return (MaybeBool)(byte)((ISdl)this).ShouldInit(__dsl_state); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureAlphaMod( - Ref texture, - [NativeTypeName("Uint8")] byte alpha - ) => DllImport.SetTextureAlphaMod(texture, alpha); + public static MaybeBool ShouldInit(Ref state) => DllImport.ShouldInit(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureAlphaModFloat(Texture* texture, float alpha) => + byte ISdl.ShouldQuit(InitState* state) => ( - (delegate* unmanaged)( - _slots[756] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[973] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[756] = nativeContext.LoadFunction( - "SDL_SetTextureAlphaModFloat", - "SDL3" - ) + : _slots[973] = nativeContext.LoadFunction("SDL_ShouldQuit", "SDL3") ) - )(texture, alpha); + )(state); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureAlphaModFloat(Texture* texture, float alpha) => - DllImport.SetTextureAlphaModFloat(texture, alpha); + public static byte ShouldQuit(InitState* state) => DllImport.ShouldQuit(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureAlphaModFloat(Ref texture, float alpha) + MaybeBool ISdl.ShouldQuit(Ref state) { - fixed (Texture* __dsl_texture = texture) + fixed (InitState* __dsl_state = state) { - return (MaybeBool) - (byte)((ISdl)this).SetTextureAlphaModFloat(__dsl_texture, alpha); + return (MaybeBool)(byte)((ISdl)this).ShouldQuit(__dsl_state); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureAlphaModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureAlphaModFloat(Ref texture, float alpha) => - DllImport.SetTextureAlphaModFloat(texture, alpha); + public static MaybeBool ShouldQuit(Ref state) => DllImport.ShouldQuit(state); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + MaybeBool ISdl.ShowCursor() => (MaybeBool)(byte)((ISdl)this).ShowCursorRaw(); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool ShowCursor() => DllImport.ShowCursor(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ShowCursorRaw() => + ( + (delegate* unmanaged)( + _slots[974] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[974] = nativeContext.LoadFunction("SDL_ShowCursor", "SDL3") + ) + )(); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte ShowCursorRaw() => DllImport.ShowCursorRaw(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, + int* buttonid ) => ( - (delegate* unmanaged)( - _slots[757] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[975] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[757] = nativeContext.LoadFunction("SDL_SetTextureBlendMode", "SDL3") + : _slots[975] = nativeContext.LoadFunction("SDL_ShowMessageBox", "SDL3") ) - )(texture, blendMode); + )(messageboxdata, buttonid); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureBlendMode( - Texture* texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetTextureBlendMode(texture, blendMode); + public static byte ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, + int* buttonid + ) => DllImport.ShowMessageBox(messageboxdata, buttonid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode + MaybeBool ISdl.ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, + Ref buttonid ) { - fixed (Texture* __dsl_texture = texture) + fixed (int* __dsl_buttonid = buttonid) + fixed (MessageBoxData* __dsl_messageboxdata = messageboxdata) { return (MaybeBool) - (byte)((ISdl)this).SetTextureBlendMode(__dsl_texture, blendMode); + (byte)((ISdl)this).ShowMessageBox(__dsl_messageboxdata, __dsl_buttonid); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureBlendMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureBlendMode( - Ref texture, - [NativeTypeName("SDL_BlendMode")] BlendMode blendMode - ) => DllImport.SetTextureBlendMode(texture, blendMode); + public static MaybeBool ShowMessageBox( + [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, + Ref buttonid + ) => DllImport.ShowMessageBox(messageboxdata, buttonid); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b + void ISdl.ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many ) => ( - (delegate* unmanaged)( - _slots[758] is not null and var loadedFnPtr + (delegate* unmanaged< + DialogFileCallback, + void*, + WindowHandle, + DialogFileFilter*, + int, + sbyte*, + byte, + void>)( + _slots[976] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[758] = nativeContext.LoadFunction("SDL_SetTextureColorMod", "SDL3") + : _slots[976] = nativeContext.LoadFunction("SDL_ShowOpenFileDialog", "SDL3") ) - )(texture, r, g, b); + )(callback, userdata, window, filters, nfilters, default_location, allow_many); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureColorMod( - Texture* texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.SetTextureColorMod(texture, r, g, b); + public static void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => + DllImport.ShowOpenFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location, + allow_many + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b + void ISdl.ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many ) { - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_default_location = default_location) + fixed (DialogFileFilter* __dsl_filters = filters) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool)(byte)((ISdl)this).SetTextureColorMod(__dsl_texture, r, g, b); + ((ISdl)this).ShowOpenFileDialog( + callback, + __dsl_userdata, + window, + __dsl_filters, + nfilters, + __dsl_default_location, + (byte)allow_many + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorMod")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureColorMod( - Ref texture, - [NativeTypeName("Uint8")] byte r, - [NativeTypeName("Uint8")] byte g, - [NativeTypeName("Uint8")] byte b - ) => DllImport.SetTextureColorMod(texture, r, g, b); + public static void ShowOpenFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) => + DllImport.ShowOpenFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location, + allow_many + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureColorModFloat(Texture* texture, float r, float g, float b) => + void ISdl.ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => ( - (delegate* unmanaged)( - _slots[759] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[977] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[759] = nativeContext.LoadFunction( - "SDL_SetTextureColorModFloat", - "SDL3" - ) + : _slots[977] = nativeContext.LoadFunction("SDL_ShowOpenFolderDialog", "SDL3") ) - )(texture, r, g, b); + )(callback, userdata, window, default_location, allow_many); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureColorModFloat(Texture* texture, float r, float g, float b) => - DllImport.SetTextureColorModFloat(texture, r, g, b); + public static void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const char *")] sbyte* default_location, + [NativeTypeName("bool")] byte allow_many + ) => DllImport.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureColorModFloat(Ref texture, float r, float g, float b) + void ISdl.ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) { - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_default_location = default_location) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool) - (byte)((ISdl)this).SetTextureColorModFloat(__dsl_texture, r, g, b); + ((ISdl)this).ShowOpenFolderDialog( + callback, + __dsl_userdata, + window, + __dsl_default_location, + (byte)allow_many + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureColorModFloat")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureColorModFloat( - Ref texture, - float r, - float g, - float b - ) => DllImport.SetTextureColorModFloat(texture, r, g, b); + public static void ShowOpenFolderDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const char *")] Ref default_location, + [NativeTypeName("bool")] MaybeBool allow_many + ) => DllImport.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => + void ISdl.ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location + ) => ( - (delegate* unmanaged)( - _slots[760] is not null and var loadedFnPtr + (delegate* unmanaged< + DialogFileCallback, + void*, + WindowHandle, + DialogFileFilter*, + int, + sbyte*, + void>)( + _slots[978] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[760] = nativeContext.LoadFunction("SDL_SetTextureScaleMode", "SDL3") + : _slots[978] = nativeContext.LoadFunction("SDL_ShowSaveFileDialog", "SDL3") ) - )(texture, scaleMode); + )(callback, userdata, window, filters, nfilters, default_location); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTextureScaleMode(Texture* texture, ScaleMode scaleMode) => - DllImport.SetTextureScaleMode(texture, scaleMode); + public static void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + void* userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, + int nfilters, + [NativeTypeName("const char *")] sbyte* default_location + ) => + DllImport.ShowSaveFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTextureScaleMode(Ref texture, ScaleMode scaleMode) + void ISdl.ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location + ) { - fixed (Texture* __dsl_texture = texture) + fixed (sbyte* __dsl_default_location = default_location) + fixed (DialogFileFilter* __dsl_filters = filters) + fixed (void* __dsl_userdata = userdata) { - return (MaybeBool) - (byte)((ISdl)this).SetTextureScaleMode(__dsl_texture, scaleMode); + ((ISdl)this).ShowSaveFileDialog( + callback, + __dsl_userdata, + window, + __dsl_filters, + nfilters, + __dsl_default_location + ); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTextureScaleMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTextureScaleMode(Ref texture, ScaleMode scaleMode) => - DllImport.SetTextureScaleMode(texture, scaleMode); + public static void ShowSaveFileDialog( + [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, + Ref userdata, + WindowHandle window, + [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, + int nfilters, + [NativeTypeName("const char *")] Ref default_location + ) => + DllImport.ShowSaveFileDialog( + callback, + userdata, + window, + filters, + nfilters, + default_location + ); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetTLS( - [NativeTypeName("SDL_TLSID *")] AtomicInt* id, - [NativeTypeName("const void *")] void* value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + byte ISdl.ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] sbyte* title, + [NativeTypeName("const char *")] sbyte* message, + WindowHandle window ) => ( - (delegate* unmanaged)( - _slots[761] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[979] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[761] = nativeContext.LoadFunction("SDL_SetTLS", "SDL3") + : _slots[979] = nativeContext.LoadFunction("SDL_ShowSimpleMessageBox", "SDL3") ) - )(id, value, destructor); + )(flags, title, message, window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetTLS( - [NativeTypeName("SDL_TLSID *")] AtomicInt* id, - [NativeTypeName("const void *")] void* value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor - ) => DllImport.SetTLS(id, value, destructor); + public static byte ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] sbyte* title, + [NativeTypeName("const char *")] sbyte* message, + WindowHandle window + ) => DllImport.ShowSimpleMessageBox(flags, title, message, window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetTLS( - [NativeTypeName("SDL_TLSID *")] Ref id, - [NativeTypeName("const void *")] Ref value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor + MaybeBool ISdl.ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] Ref title, + [NativeTypeName("const char *")] Ref message, + WindowHandle window ) { - fixed (void* __dsl_value = value) - fixed (AtomicInt* __dsl_id = id) + fixed (sbyte* __dsl_message = message) + fixed (sbyte* __dsl_title = title) { - return (MaybeBool)(byte)((ISdl)this).SetTLS(__dsl_id, __dsl_value, destructor); + return (MaybeBool) + (byte)((ISdl)this).ShowSimpleMessageBox(flags, __dsl_title, __dsl_message, window); } } [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetTLS")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetTLS( - [NativeTypeName("SDL_TLSID *")] Ref id, - [NativeTypeName("const void *")] Ref value, - [NativeTypeName("SDL_TLSDestructorCallback")] TLSDestructorCallback destructor - ) => DllImport.SetTLS(id, value, destructor); + public static MaybeBool ShowSimpleMessageBox( + [NativeTypeName("SDL_MessageBoxFlags")] uint flags, + [NativeTypeName("const char *")] Ref title, + [NativeTypeName("const char *")] Ref message, + WindowHandle window + ) => DllImport.ShowSimpleMessageBox(flags, title, message, window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowAlwaysOnTop(WindowHandle window, [NativeTypeName("bool")] byte on_top) => - ( - (delegate* unmanaged)( - _slots[762] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[762] = nativeContext.LoadFunction("SDL_SetWindowAlwaysOnTop", "SDL3") - ) - )(window, on_top); + MaybeBool ISdl.ShowWindow(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).ShowWindowRaw(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] byte on_top - ) => DllImport.SetWindowAlwaysOnTop(window, on_top); + public static MaybeBool ShowWindow(WindowHandle window) => DllImport.ShowWindow(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool on_top - ) => (MaybeBool)(byte)((ISdl)this).SetWindowAlwaysOnTop(window, (byte)on_top); + byte ISdl.ShowWindowRaw(WindowHandle window) => + ( + (delegate* unmanaged)( + _slots[980] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[980] = nativeContext.LoadFunction("SDL_ShowWindow", "SDL3") + ) + )(window); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAlwaysOnTop")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowAlwaysOnTop( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool on_top - ) => DllImport.SetWindowAlwaysOnTop(window, on_top); + public static byte ShowWindowRaw(WindowHandle window) => DllImport.ShowWindowRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowAspectRatio( - WindowHandle window, - float min_aspect, - float max_aspect - ) => - (MaybeBool)(byte)((ISdl)this).SetWindowAspectRatioRaw(window, min_aspect, max_aspect); + MaybeBool ISdl.ShowWindowSystemMenu(WindowHandle window, int x, int y) => + (MaybeBool)(byte)((ISdl)this).ShowWindowSystemMenuRaw(window, x, y); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowAspectRatio( - WindowHandle window, - float min_aspect, - float max_aspect - ) => DllImport.SetWindowAspectRatio(window, min_aspect, max_aspect); + public static MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => + DllImport.ShowWindowSystemMenu(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowAspectRatioRaw(WindowHandle window, float min_aspect, float max_aspect) => + byte ISdl.ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => ( - (delegate* unmanaged)( - _slots[763] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[981] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[763] = nativeContext.LoadFunction("SDL_SetWindowAspectRatio", "SDL3") + : _slots[981] = nativeContext.LoadFunction("SDL_ShowWindowSystemMenu", "SDL3") ) - )(window, min_aspect, max_aspect); + )(window, x, y); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowAspectRatio")] + [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowAspectRatioRaw( - WindowHandle window, - float min_aspect, - float max_aspect - ) => DllImport.SetWindowAspectRatioRaw(window, min_aspect, max_aspect); + public static byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => + DllImport.ShowWindowSystemMenuRaw(window, x, y); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowBordered(WindowHandle window, [NativeTypeName("bool")] byte bordered) => + void ISdl.SignalCondition(ConditionHandle cond) => ( - (delegate* unmanaged)( - _slots[764] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[982] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[764] = nativeContext.LoadFunction("SDL_SetWindowBordered", "SDL3") + : _slots[982] = nativeContext.LoadFunction("SDL_SignalCondition", "SDL3") ) - )(window, bordered); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowBordered( - WindowHandle window, - [NativeTypeName("bool")] byte bordered - ) => DllImport.SetWindowBordered(window, bordered); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowBordered( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool bordered - ) => (MaybeBool)(byte)((ISdl)this).SetWindowBordered(window, (byte)bordered); + )(cond); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowBordered")] + [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowBordered( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool bordered - ) => DllImport.SetWindowBordered(window, bordered); + public static void SignalCondition(ConditionHandle cond) => DllImport.SignalCondition(cond); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowFocusable(WindowHandle window, [NativeTypeName("bool")] byte focusable) => + void ISdl.SignalSemaphore(SemaphoreHandle sem) => ( - (delegate* unmanaged)( - _slots[765] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[983] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[765] = nativeContext.LoadFunction("SDL_SetWindowFocusable", "SDL3") + : _slots[983] = nativeContext.LoadFunction("SDL_SignalSemaphore", "SDL3") ) - )(window, focusable); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] byte focusable - ) => DllImport.SetWindowFocusable(window, focusable); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool focusable - ) => (MaybeBool)(byte)((ISdl)this).SetWindowFocusable(window, (byte)focusable); + )(sem); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFocusable")] + [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowFocusable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool focusable - ) => DllImport.SetWindowFocusable(window, focusable); + public static void SignalSemaphore(SemaphoreHandle sem) => DllImport.SignalSemaphore(sem); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowFullscreen(WindowHandle window, [NativeTypeName("bool")] byte fullscreen) => + double ISdl.Sin(double x) => ( - (delegate* unmanaged)( - _slots[766] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[984] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[766] = nativeContext.LoadFunction("SDL_SetWindowFullscreen", "SDL3") + : _slots[984] = nativeContext.LoadFunction("SDL_sin", "SDL3") ) - )(window, fullscreen); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] byte fullscreen - ) => DllImport.SetWindowFullscreen(window, fullscreen); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool fullscreen - ) => (MaybeBool)(byte)((ISdl)this).SetWindowFullscreen(window, (byte)fullscreen); + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreen")] + [NativeFunction("SDL3", EntryPoint = "SDL_sin")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowFullscreen( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool fullscreen - ) => DllImport.SetWindowFullscreen(window, fullscreen); + public static double Sin(double x) => DllImport.Sin(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode - ) => + float ISdl.Sinf(float x) => ( - (delegate* unmanaged)( - _slots[767] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[985] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[767] = nativeContext.LoadFunction( - "SDL_SetWindowFullscreenMode", - "SDL3" - ) + : _slots[985] = nativeContext.LoadFunction("SDL_sinf", "SDL3") ) - )(window, mode); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] DisplayMode* mode - ) => DllImport.SetWindowFullscreenMode(window, mode); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] Ref mode - ) - { - fixed (DisplayMode* __dsl_mode = mode) - { - return (MaybeBool)(byte)((ISdl)this).SetWindowFullscreenMode(window, __dsl_mode); - } - } + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowFullscreenMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_sinf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowFullscreenMode( - WindowHandle window, - [NativeTypeName("const SDL_DisplayMode *")] Ref mode - ) => DllImport.SetWindowFullscreenMode(window, mode); + public static float Sinf(float x) => DllImport.Sinf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - void* callback_data - ) => + double ISdl.Sqrt(double x) => ( - (delegate* unmanaged)( - _slots[768] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[986] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[768] = nativeContext.LoadFunction("SDL_SetWindowHitTest", "SDL3") + : _slots[986] = nativeContext.LoadFunction("SDL_sqrt", "SDL3") ) - )(window, callback, callback_data); + )(x); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [NativeFunction("SDL3", EntryPoint = "SDL_sqrt")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - void* callback_data - ) => DllImport.SetWindowHitTest(window, callback, callback_data); + public static double Sqrt(double x) => DllImport.Sqrt(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - Ref callback_data - ) - { - fixed (void* __dsl_callback_data = callback_data) - { - return (MaybeBool) - (byte)((ISdl)this).SetWindowHitTest(window, callback, __dsl_callback_data); - } - } + float ISdl.Sqrtf(float x) => + ( + (delegate* unmanaged)( + _slots[987] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[987] = nativeContext.LoadFunction("SDL_sqrtf", "SDL3") + ) + )(x); - [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowHitTest")] + [NativeFunction("SDL3", EntryPoint = "SDL_sqrtf")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowHitTest( - WindowHandle window, - [NativeTypeName("SDL_HitTest")] HitTest callback, - Ref callback_data - ) => DllImport.SetWindowHitTest(window, callback, callback_data); + public static float Sqrtf(float x) => DllImport.Sqrtf(x); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowIcon(WindowHandle window, Surface* icon) => + void ISdl.Srand([NativeTypeName("Uint64")] ulong seed) => ( - (delegate* unmanaged)( - _slots[769] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[988] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[769] = nativeContext.LoadFunction("SDL_SetWindowIcon", "SDL3") + : _slots[988] = nativeContext.LoadFunction("SDL_srand", "SDL3") ) - )(window, icon); + )(seed); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [NativeFunction("SDL3", EntryPoint = "SDL_srand")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowIcon(WindowHandle window, Surface* icon) => - DllImport.SetWindowIcon(window, icon); + public static void Srand([NativeTypeName("Uint64")] ulong seed) => DllImport.Srand(seed); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowIcon(WindowHandle window, Ref icon) - { - fixed (Surface* __dsl_icon = icon) - { - return (MaybeBool)(byte)((ISdl)this).SetWindowIcon(window, __dsl_icon); - } - } + MaybeBool ISdl.StartTextInput(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).StartTextInputRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowIcon")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowIcon(WindowHandle window, Ref icon) => - DllImport.SetWindowIcon(window, icon); + public static MaybeBool StartTextInput(WindowHandle window) => + DllImport.StartTextInput(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowKeyboardGrab(WindowHandle window, [NativeTypeName("bool")] byte grabbed) => + byte ISdl.StartTextInputRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[770] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[989] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[770] = nativeContext.LoadFunction("SDL_SetWindowKeyboardGrab", "SDL3") + : _slots[989] = nativeContext.LoadFunction("SDL_StartTextInput", "SDL3") ) - )(window, grabbed); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowKeyboardGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => DllImport.SetWindowKeyboardGrab(window, grabbed); + public static byte StartTextInputRaw(WindowHandle window) => + DllImport.StartTextInputRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowKeyboardGrab( + MaybeBool ISdl.StartTextInputWithProperties( WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => (MaybeBool)(byte)((ISdl)this).SetWindowKeyboardGrab(window, (byte)grabbed); + [NativeTypeName("SDL_PropertiesID")] uint props + ) => (MaybeBool)(byte)((ISdl)this).StartTextInputWithPropertiesRaw(window, props); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowKeyboardGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowKeyboardGrab( + public static MaybeBool StartTextInputWithProperties( WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => DllImport.SetWindowKeyboardGrab(window, grabbed); + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.StartTextInputWithProperties(window, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => - (MaybeBool)(byte)((ISdl)this).SetWindowMaximumSizeRaw(window, max_w, max_h); + byte ISdl.StartTextInputWithPropertiesRaw( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => + ( + (delegate* unmanaged)( + _slots[990] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[990] = nativeContext.LoadFunction( + "SDL_StartTextInputWithProperties", + "SDL3" + ) + ) + )(window, props); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowMaximumSize(WindowHandle window, int max_w, int max_h) => - DllImport.SetWindowMaximumSize(window, max_w, max_h); + public static byte StartTextInputWithPropertiesRaw( + WindowHandle window, + [NativeTypeName("SDL_PropertiesID")] uint props + ) => DllImport.StartTextInputWithPropertiesRaw(window, props); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => + uint ISdl.StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ) => ( - (delegate* unmanaged)( - _slots[771] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[991] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[771] = nativeContext.LoadFunction("SDL_SetWindowMaximumSize", "SDL3") + : _slots[991] = nativeContext.LoadFunction("SDL_StepBackUTF8", "SDL3") ) - )(window, max_w, max_h); + )(start, pstr); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMaximumSize")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowMaximumSizeRaw(WindowHandle window, int max_w, int max_h) => - DllImport.SetWindowMaximumSizeRaw(window, max_w, max_h); + public static uint StepBackUTF8( + [NativeTypeName("const char *")] sbyte* start, + [NativeTypeName("const char **")] sbyte** pstr + ) => DllImport.StepBackUTF8(start, pstr); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => - (MaybeBool)(byte)((ISdl)this).SetWindowMinimumSizeRaw(window, min_w, min_h); + uint ISdl.StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ) + { + fixed (sbyte** __dsl_pstr = pstr) + fixed (sbyte* __dsl_start = start) + { + return (uint)((ISdl)this).StepBackUTF8(__dsl_start, __dsl_pstr); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("Uint32")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepBackUTF8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowMinimumSize(WindowHandle window, int min_w, int min_h) => - DllImport.SetWindowMinimumSize(window, min_w, min_h); + public static uint StepBackUTF8( + [NativeTypeName("const char *")] Ref start, + [NativeTypeName("const char **")] Ref2D pstr + ) => DllImport.StepBackUTF8(start, pstr); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => + uint ISdl.StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ) => ( - (delegate* unmanaged)( - _slots[772] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[992] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[772] = nativeContext.LoadFunction("SDL_SetWindowMinimumSize", "SDL3") + : _slots[992] = nativeContext.LoadFunction("SDL_StepUTF8", "SDL3") ) - )(window, min_w, min_h); + )(pstr, pslen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMinimumSize")] + [return: NativeTypeName("Uint32")] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowMinimumSizeRaw(WindowHandle window, int min_w, int min_h) => - DllImport.SetWindowMinimumSizeRaw(window, min_w, min_h); + public static uint StepUTF8( + [NativeTypeName("const char **")] sbyte** pstr, + [NativeTypeName("size_t *")] nuint* pslen + ) => DllImport.StepUTF8(pstr, pslen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => - ( - (delegate* unmanaged)( - _slots[773] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[773] = nativeContext.LoadFunction("SDL_SetWindowModal", "SDL3") - ) - )(window, modal); + uint ISdl.StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ) + { + fixed (nuint* __dsl_pslen = pslen) + fixed (sbyte** __dsl_pstr = pstr) + { + return (uint)((ISdl)this).StepUTF8(__dsl_pstr, __dsl_pslen); + } + } - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [return: NativeTypeName("Uint32")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StepUTF8")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowModal(WindowHandle window, [NativeTypeName("bool")] byte modal) => - DllImport.SetWindowModal(window, modal); + public static uint StepUTF8( + [NativeTypeName("const char **")] Ref2D pstr, + [NativeTypeName("size_t *")] Ref pslen + ) => DllImport.StepUTF8(pstr, pslen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowModal( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool modal - ) => (MaybeBool)(byte)((ISdl)this).SetWindowModal(window, (byte)modal); + MaybeBool ISdl.StopHapticEffect(HapticHandle haptic, int effect) => + (MaybeBool)(byte)((ISdl)this).StopHapticEffectRaw(haptic, effect); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowModal")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowModal( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool modal - ) => DllImport.SetWindowModal(window, modal); + public static MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => + DllImport.StopHapticEffect(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowMouseGrab(WindowHandle window, [NativeTypeName("bool")] byte grabbed) => + byte ISdl.StopHapticEffectRaw(HapticHandle haptic, int effect) => ( - (delegate* unmanaged)( - _slots[774] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[993] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[774] = nativeContext.LoadFunction("SDL_SetWindowMouseGrab", "SDL3") + : _slots[993] = nativeContext.LoadFunction("SDL_StopHapticEffect", "SDL3") ) - )(window, grabbed); + )(haptic, effect); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] byte grabbed - ) => DllImport.SetWindowMouseGrab(window, grabbed); + public static byte StopHapticEffectRaw(HapticHandle haptic, int effect) => + DllImport.StopHapticEffectRaw(haptic, effect); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => (MaybeBool)(byte)((ISdl)this).SetWindowMouseGrab(window, (byte)grabbed); + MaybeBool ISdl.StopHapticEffects(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).StopHapticEffectsRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseGrab")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowMouseGrab( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool grabbed - ) => DllImport.SetWindowMouseGrab(window, grabbed); - - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => - ( - (delegate* unmanaged)( - _slots[775] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[775] = nativeContext.LoadFunction("SDL_SetWindowMouseRect", "SDL3") - ) - )(window, rect); - - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Rect* rect - ) => DllImport.SetWindowMouseRect(window, rect); + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool StopHapticEffects(HapticHandle haptic) => + DllImport.StopHapticEffects(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) - { - fixed (Rect* __dsl_rect = rect) - { - return (MaybeBool)(byte)((ISdl)this).SetWindowMouseRect(window, __dsl_rect); - } - } + byte ISdl.StopHapticEffectsRaw(HapticHandle haptic) => + ( + (delegate* unmanaged)( + _slots[994] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[994] = nativeContext.LoadFunction("SDL_StopHapticEffects", "SDL3") + ) + )(haptic); [return: NativeTypeName("bool")] - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowMouseRect")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowMouseRect( - WindowHandle window, - [NativeTypeName("const SDL_Rect *")] Ref rect - ) => DllImport.SetWindowMouseRect(window, rect); + public static byte StopHapticEffectsRaw(HapticHandle haptic) => + DllImport.StopHapticEffectsRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowOpacity(WindowHandle window, float opacity) => - (MaybeBool)(byte)((ISdl)this).SetWindowOpacityRaw(window, opacity); + MaybeBool ISdl.StopHapticRumble(HapticHandle haptic) => + (MaybeBool)(byte)((ISdl)this).StopHapticRumbleRaw(haptic); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowOpacity(WindowHandle window, float opacity) => - DllImport.SetWindowOpacity(window, opacity); + public static MaybeBool StopHapticRumble(HapticHandle haptic) => + DllImport.StopHapticRumble(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowOpacityRaw(WindowHandle window, float opacity) => + byte ISdl.StopHapticRumbleRaw(HapticHandle haptic) => ( - (delegate* unmanaged)( - _slots[776] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[995] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[776] = nativeContext.LoadFunction("SDL_SetWindowOpacity", "SDL3") + : _slots[995] = nativeContext.LoadFunction("SDL_StopHapticRumble", "SDL3") ) - )(window, opacity); + )(haptic); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowOpacity")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowOpacityRaw(WindowHandle window, float opacity) => - DllImport.SetWindowOpacityRaw(window, opacity); + public static byte StopHapticRumbleRaw(HapticHandle haptic) => + DllImport.StopHapticRumbleRaw(haptic); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowParent(WindowHandle window, WindowHandle parent) => - (MaybeBool)(byte)((ISdl)this).SetWindowParentRaw(window, parent); + MaybeBool ISdl.StopTextInput(WindowHandle window) => + (MaybeBool)(byte)((ISdl)this).StopTextInputRaw(window); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowParent(WindowHandle window, WindowHandle parent) => - DllImport.SetWindowParent(window, parent); + public static MaybeBool StopTextInput(WindowHandle window) => + DllImport.StopTextInput(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowParentRaw(WindowHandle window, WindowHandle parent) => + byte ISdl.StopTextInputRaw(WindowHandle window) => ( - (delegate* unmanaged)( - _slots[777] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[996] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[777] = nativeContext.LoadFunction("SDL_SetWindowParent", "SDL3") + : _slots[996] = nativeContext.LoadFunction("SDL_StopTextInput", "SDL3") ) - )(window, parent); + )(window); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowParent")] + [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowParentRaw(WindowHandle window, WindowHandle parent) => - DllImport.SetWindowParentRaw(window, parent); + public static byte StopTextInputRaw(WindowHandle window) => DllImport.StopTextInputRaw(window); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowPosition(WindowHandle window, int x, int y) => - (MaybeBool)(byte)((ISdl)this).SetWindowPositionRaw(window, x, y); + MaybeBool ISdl.StorageReady(StorageHandle storage) => + (MaybeBool)(byte)((ISdl)this).StorageReadyRaw(storage); [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowPosition(WindowHandle window, int x, int y) => - DllImport.SetWindowPosition(window, x, y); + public static MaybeBool StorageReady(StorageHandle storage) => + DllImport.StorageReady(storage); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowPositionRaw(WindowHandle window, int x, int y) => + byte ISdl.StorageReadyRaw(StorageHandle storage) => ( - (delegate* unmanaged)( - _slots[778] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[997] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[778] = nativeContext.LoadFunction("SDL_SetWindowPosition", "SDL3") + : _slots[997] = nativeContext.LoadFunction("SDL_StorageReady", "SDL3") ) - )(window, x, y); + )(storage); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowPosition")] + [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowPositionRaw(WindowHandle window, int x, int y) => - DllImport.SetWindowPositionRaw(window, x, y); + public static byte StorageReadyRaw(StorageHandle storage) => DllImport.StorageReadyRaw(storage); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] byte enabled + int ISdl.Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 ) => ( - (delegate* unmanaged)( - _slots[779] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[998] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[779] = nativeContext.LoadFunction( - "SDL_SetWindowRelativeMouseMode", - "SDL3" - ) + : _slots[998] = nativeContext.LoadFunction("SDL_strcasecmp", "SDL3") ) - )(window, enabled); + )(str1, str2); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] byte enabled - ) => DllImport.SetWindowRelativeMouseMode(window, enabled); + public static int Strcasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => DllImport.Strcasecmp(str1, str2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool enabled - ) => (MaybeBool)(byte)((ISdl)this).SetWindowRelativeMouseMode(window, (byte)enabled); + int ISdl.Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)((ISdl)this).Strcasecmp(__dsl_str1, __dsl_str2); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowRelativeMouseMode")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasecmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowRelativeMouseMode( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool enabled - ) => DllImport.SetWindowRelativeMouseMode(window, enabled); + public static int Strcasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) => DllImport.Strcasecmp(str1, str2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowResizable(WindowHandle window, [NativeTypeName("bool")] byte resizable) => + sbyte* ISdl.Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => ( - (delegate* unmanaged)( - _slots[780] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[999] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[780] = nativeContext.LoadFunction("SDL_SetWindowResizable", "SDL3") + : _slots[999] = nativeContext.LoadFunction("SDL_strcasestr", "SDL3") ) - )(window, resizable); + )(haystack, needle); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] byte resizable - ) => DllImport.SetWindowResizable(window, resizable); + public static sbyte* Strcasestr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => DllImport.Strcasestr(haystack, needle); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool resizable - ) => (MaybeBool)(byte)((ISdl)this).SetWindowResizable(window, (byte)resizable); + Ptr ISdl.Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) + { + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) + { + return (sbyte*)((ISdl)this).Strcasestr(__dsl_haystack, __dsl_needle); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowResizable")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcasestr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowResizable( - WindowHandle window, - [NativeTypeName("bool")] MaybeBool resizable - ) => DllImport.SetWindowResizable(window, resizable); + public static Ptr Strcasestr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) => DllImport.Strcasestr(haystack, needle); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowShape(WindowHandle window, Surface* shape) => + sbyte* ISdl.Strchr([NativeTypeName("const char *")] sbyte* str, int c) => ( - (delegate* unmanaged)( - _slots[781] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1000] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[781] = nativeContext.LoadFunction("SDL_SetWindowShape", "SDL3") + : _slots[1000] = nativeContext.LoadFunction("SDL_strchr", "SDL3") ) - )(window, shape); + )(str, c); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowShape(WindowHandle window, Surface* shape) => - DllImport.SetWindowShape(window, shape); + public static sbyte* Strchr([NativeTypeName("const char *")] sbyte* str, int c) => + DllImport.Strchr(str, c); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowShape(WindowHandle window, Ref shape) + Ptr ISdl.Strchr([NativeTypeName("const char *")] Ref str, int c) { - fixed (Surface* __dsl_shape = shape) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)((ISdl)this).SetWindowShape(window, __dsl_shape); + return (sbyte*)((ISdl)this).Strchr(__dsl_str, c); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowShape")] + [NativeFunction("SDL3", EntryPoint = "SDL_strchr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowShape(WindowHandle window, Ref shape) => - DllImport.SetWindowShape(window, shape); + public static Ptr Strchr([NativeTypeName("const char *")] Ref str, int c) => + DllImport.Strchr(str, c); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowSize(WindowHandle window, int w, int h) => - (MaybeBool)(byte)((ISdl)this).SetWindowSizeRaw(window, w, h); + int ISdl.Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => + ( + (delegate* unmanaged)( + _slots[1001] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1001] = nativeContext.LoadFunction("SDL_strcmp", "SDL3") + ) + )(str1, str2); + + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Strcmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2 + ) => DllImport.Strcmp(str1, str2); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)((ISdl)this).Strcmp(__dsl_str1, __dsl_str2); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [NativeFunction("SDL3", EntryPoint = "SDL_strcmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowSize(WindowHandle window, int w, int h) => - DllImport.SetWindowSize(window, w, h); + public static int Strcmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2 + ) => DllImport.Strcmp(str1, str2); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowSizeRaw(WindowHandle window, int w, int h) => + sbyte* ISdl.Strdup([NativeTypeName("const char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[782] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1002] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[782] = nativeContext.LoadFunction("SDL_SetWindowSize", "SDL3") + : _slots[1002] = nativeContext.LoadFunction("SDL_strdup", "SDL3") ) - )(window, w, h); + )(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSize")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowSizeRaw(WindowHandle window, int w, int h) => - DllImport.SetWindowSizeRaw(window, w, h); + public static sbyte* Strdup([NativeTypeName("const char *")] sbyte* str) => + DllImport.Strdup(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowSurfaceVSync(WindowHandle window, int vsync) => - (MaybeBool)(byte)((ISdl)this).SetWindowSurfaceVSyncRaw(window, vsync); + Ptr ISdl.Strdup([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Strdup(__dsl_str); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_strdup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowSurfaceVSync(WindowHandle window, int vsync) => - DllImport.SetWindowSurfaceVSync(window, vsync); + public static Ptr Strdup([NativeTypeName("const char *")] Ref str) => + DllImport.Strdup(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => + Guid ISdl.StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => ( - (delegate* unmanaged)( - _slots[783] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1003] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[783] = nativeContext.LoadFunction("SDL_SetWindowSurfaceVSync", "SDL3") + : _slots[1003] = nativeContext.LoadFunction("SDL_StringToGUID", "SDL3") ) - )(window, vsync); + )(pchGUID); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowSurfaceVSync")] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowSurfaceVSyncRaw(WindowHandle window, int vsync) => - DllImport.SetWindowSurfaceVSyncRaw(window, vsync); + public static Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => + DllImport.StringToGuid(pchGUID); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.SetWindowTitle(WindowHandle window, [NativeTypeName("const char *")] sbyte* title) => + Guid ISdl.StringToGuid([NativeTypeName("const char *")] Ref pchGUID) + { + fixed (sbyte* __dsl_pchGUID = pchGUID) + { + return (Guid)((ISdl)this).StringToGuid(__dsl_pchGUID); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) => + DllImport.StringToGuid(pchGUID); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => ( - (delegate* unmanaged)( - _slots[784] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1004] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[784] = nativeContext.LoadFunction("SDL_SetWindowTitle", "SDL3") + : _slots[1004] = nativeContext.LoadFunction("SDL_strlcat", "SDL3") ) - )(window, title); + )(dst, src, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] sbyte* title - ) => DllImport.SetWindowTitle(window, title); + public static nuint Strlcat( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strlcat(dst, src, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] Ref title + nuint ISdl.Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (sbyte* __dsl_title = title) + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) { - return (MaybeBool)(byte)((ISdl)this).SetWindowTitle(window, __dsl_title); + return (nuint)((ISdl)this).Strlcat(__dsl_dst, __dsl_src, maxlen); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_SetWindowTitle")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcat")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool SetWindowTitle( - WindowHandle window, - [NativeTypeName("const char *")] Ref title - ) => DllImport.SetWindowTitle(window, title); + public static nuint Strlcat( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strlcat(dst, src, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShouldInit(InitState* state) => + nuint ISdl.Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => ( - (delegate* unmanaged)( - _slots[785] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1005] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[785] = nativeContext.LoadFunction("SDL_ShouldInit", "SDL3") + : _slots[1005] = nativeContext.LoadFunction("SDL_strlcpy", "SDL3") ) - )(state); + )(dst, src, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShouldInit(InitState* state) => DllImport.ShouldInit(state); + public static nuint Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strlcpy(dst, src, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShouldInit(Ref state) + nuint ISdl.Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) { - fixed (InitState* __dsl_state = state) + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) { - return (MaybeBool)(byte)((ISdl)this).ShouldInit(__dsl_state); + return (nuint)((ISdl)this).Strlcpy(__dsl_dst, __dsl_src, maxlen); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldInit")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlcpy")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShouldInit(Ref state) => DllImport.ShouldInit(state); + public static nuint Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strlcpy(dst, src, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShouldQuit(InitState* state) => + nuint ISdl.Strlen([NativeTypeName("const char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[786] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1006] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[786] = nativeContext.LoadFunction("SDL_ShouldQuit", "SDL3") + : _slots[1006] = nativeContext.LoadFunction("SDL_strlen", "SDL3") ) - )(state); + )(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShouldQuit(InitState* state) => DllImport.ShouldQuit(state); + public static nuint Strlen([NativeTypeName("const char *")] sbyte* str) => + DllImport.Strlen(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShouldQuit(Ref state) + nuint ISdl.Strlen([NativeTypeName("const char *")] Ref str) { - fixed (InitState* __dsl_state = state) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool)(byte)((ISdl)this).ShouldQuit(__dsl_state); + return (nuint)((ISdl)this).Strlen(__dsl_str); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("size_t")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShouldQuit")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlen")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShouldQuit(Ref state) => DllImport.ShouldQuit(state); + public static nuint Strlen([NativeTypeName("const char *")] Ref str) => + DllImport.Strlen(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShowCursor() => (MaybeBool)(byte)((ISdl)this).ShowCursorRaw(); + sbyte* ISdl.Strlwr([NativeTypeName("char *")] sbyte* str) => + ( + (delegate* unmanaged)( + _slots[1007] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1007] = nativeContext.LoadFunction("SDL_strlwr", "SDL3") + ) + )(str); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* Strlwr([NativeTypeName("char *")] sbyte* str) => DllImport.Strlwr(str); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Strlwr([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Strlwr(__dsl_str); + } + } + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_strlwr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShowCursor() => DllImport.ShowCursor(); + public static Ptr Strlwr([NativeTypeName("char *")] Ref str) => + DllImport.Strlwr(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShowCursorRaw() => + int ISdl.Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => ( - (delegate* unmanaged)( - _slots[787] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1008] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[787] = nativeContext.LoadFunction("SDL_ShowCursor", "SDL3") + : _slots[1008] = nativeContext.LoadFunction("SDL_strncasecmp", "SDL3") ) - )(); + )(str1, str2, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowCursor")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShowCursorRaw() => DllImport.ShowCursorRaw(); + public static int Strncasecmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strncasecmp(str1, str2, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, - int* buttonid + int ISdl.Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) + { + return (int)((ISdl)this).Strncasecmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strncasecmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Strncasecmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strncasecmp(str1, str2, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen ) => ( - (delegate* unmanaged)( - _slots[788] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1009] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[788] = nativeContext.LoadFunction("SDL_ShowMessageBox", "SDL3") + : _slots[1009] = nativeContext.LoadFunction("SDL_strncmp", "SDL3") ) - )(messageboxdata, buttonid); + )(str1, str2, maxlen); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] MessageBoxData* messageboxdata, - int* buttonid - ) => DllImport.ShowMessageBox(messageboxdata, buttonid); + public static int Strncmp( + [NativeTypeName("const char *")] sbyte* str1, + [NativeTypeName("const char *")] sbyte* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strncmp(str1, str2, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, - Ref buttonid + int ISdl.Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (int* __dsl_buttonid = buttonid) - fixed (MessageBoxData* __dsl_messageboxdata = messageboxdata) + fixed (sbyte* __dsl_str2 = str2) + fixed (sbyte* __dsl_str1 = str1) { - return (MaybeBool) - (byte)((ISdl)this).ShowMessageBox(__dsl_messageboxdata, __dsl_buttonid); + return (int)((ISdl)this).Strncmp(__dsl_str1, __dsl_str2, maxlen); } } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_strncmp")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShowMessageBox( - [NativeTypeName("const SDL_MessageBoxData *")] Ref messageboxdata, - Ref buttonid - ) => DllImport.ShowMessageBox(messageboxdata, buttonid); + public static int Strncmp( + [NativeTypeName("const char *")] Ref str1, + [NativeTypeName("const char *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strncmp(str1, str2, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many + sbyte* ISdl.Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen ) => ( - (delegate* unmanaged< - DialogFileCallback, - void*, - WindowHandle, - DialogFileFilter*, - int, - sbyte*, - byte, - void>)( - _slots[789] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1010] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[789] = nativeContext.LoadFunction("SDL_ShowOpenFileDialog", "SDL3") + : _slots[1010] = nativeContext.LoadFunction("SDL_strndup", "SDL3") ) - )(callback, userdata, window, filters, nfilters, default_location, allow_many); + )(str, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => - DllImport.ShowOpenFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location, - allow_many - ); + public static sbyte* Strndup( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strndup(str, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many + Ptr ISdl.Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (sbyte* __dsl_default_location = default_location) - fixed (DialogFileFilter* __dsl_filters = filters) - fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_str = str) { - ((ISdl)this).ShowOpenFileDialog( - callback, - __dsl_userdata, - window, - __dsl_filters, - nfilters, - __dsl_default_location, - (byte)allow_many - ); + return (sbyte*)((ISdl)this).Strndup(__dsl_str, maxlen); } } + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_strndup")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowOpenFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many - ) => - DllImport.ShowOpenFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location, - allow_many - ); + public static Ptr Strndup( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strndup(str, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many + nuint ISdl.Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen ) => ( - (delegate* unmanaged)( - _slots[790] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1011] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[790] = nativeContext.LoadFunction("SDL_ShowOpenFolderDialog", "SDL3") + : _slots[1011] = nativeContext.LoadFunction("SDL_strnlen", "SDL3") ) - )(callback, userdata, window, default_location, allow_many); + )(str, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const char *")] sbyte* default_location, - [NativeTypeName("bool")] byte allow_many - ) => DllImport.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); + public static nuint Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strnlen(str, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many + nuint ISdl.Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (sbyte* __dsl_default_location = default_location) - fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_str = str) { - ((ISdl)this).ShowOpenFolderDialog( - callback, - __dsl_userdata, - window, - __dsl_default_location, - (byte)allow_many - ); + return (nuint)((ISdl)this).Strnlen(__dsl_str, maxlen); } } - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowOpenFolderDialog")] - [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowOpenFolderDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const char *")] Ref default_location, - [NativeTypeName("bool")] MaybeBool allow_many - ) => DllImport.ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strnlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strnlen(str, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location + sbyte* ISdl.Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen ) => ( - (delegate* unmanaged< - DialogFileCallback, - void*, - WindowHandle, - DialogFileFilter*, - int, - sbyte*, - void>)( - _slots[791] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1012] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[791] = nativeContext.LoadFunction("SDL_ShowSaveFileDialog", "SDL3") + : _slots[1012] = nativeContext.LoadFunction("SDL_strnstr", "SDL3") ) - )(callback, userdata, window, filters, nfilters, default_location); + )(haystack, needle, maxlen); - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - void* userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] DialogFileFilter* filters, - int nfilters, - [NativeTypeName("const char *")] sbyte* default_location - ) => - DllImport.ShowSaveFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location - ); + public static sbyte* Strnstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strnstr(haystack, needle, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location + Ptr ISdl.Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen ) { - fixed (sbyte* __dsl_default_location = default_location) - fixed (DialogFileFilter* __dsl_filters = filters) - fixed (void* __dsl_userdata = userdata) + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) { - ((ISdl)this).ShowSaveFileDialog( - callback, - __dsl_userdata, - window, - __dsl_filters, - nfilters, - __dsl_default_location - ); + return (sbyte*)((ISdl)this).Strnstr(__dsl_haystack, __dsl_needle, maxlen); } } + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSaveFileDialog")] + [NativeFunction("SDL3", EntryPoint = "SDL_strnstr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void ShowSaveFileDialog( - [NativeTypeName("SDL_DialogFileCallback")] DialogFileCallback callback, - Ref userdata, - WindowHandle window, - [NativeTypeName("const SDL_DialogFileFilter *")] Ref filters, - int nfilters, - [NativeTypeName("const char *")] Ref default_location - ) => - DllImport.ShowSaveFileDialog( - callback, - userdata, - window, - filters, - nfilters, - default_location - ); + public static Ptr Strnstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Strnstr(haystack, needle, maxlen); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] sbyte* title, - [NativeTypeName("const char *")] sbyte* message, - WindowHandle window + sbyte* ISdl.Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset ) => ( - (delegate* unmanaged)( - _slots[792] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1013] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[792] = nativeContext.LoadFunction("SDL_ShowSimpleMessageBox", "SDL3") + : _slots[1013] = nativeContext.LoadFunction("SDL_strpbrk", "SDL3") ) - )(flags, title, message, window); + )(str, breakset); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] sbyte* title, - [NativeTypeName("const char *")] sbyte* message, - WindowHandle window - ) => DllImport.ShowSimpleMessageBox(flags, title, message, window); + public static sbyte* Strpbrk( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("const char *")] sbyte* breakset + ) => DllImport.Strpbrk(str, breakset); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] Ref title, - [NativeTypeName("const char *")] Ref message, - WindowHandle window + Ptr ISdl.Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset ) { - fixed (sbyte* __dsl_message = message) - fixed (sbyte* __dsl_title = title) + fixed (sbyte* __dsl_breakset = breakset) + fixed (sbyte* __dsl_str = str) { - return (MaybeBool) - (byte)((ISdl)this).ShowSimpleMessageBox(flags, __dsl_title, __dsl_message, window); + return (sbyte*)((ISdl)this).Strpbrk(__dsl_str, __dsl_breakset); } } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowSimpleMessageBox")] + [NativeFunction("SDL3", EntryPoint = "SDL_strpbrk")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShowSimpleMessageBox( - [NativeTypeName("SDL_MessageBoxFlags")] uint flags, - [NativeTypeName("const char *")] Ref title, - [NativeTypeName("const char *")] Ref message, - WindowHandle window - ) => DllImport.ShowSimpleMessageBox(flags, title, message, window); + public static Ptr Strpbrk( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("const char *")] Ref breakset + ) => DllImport.Strpbrk(str, breakset); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShowWindow(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).ShowWindowRaw(window); + sbyte* ISdl.Strrchr([NativeTypeName("const char *")] sbyte* str, int c) => + ( + (delegate* unmanaged)( + _slots[1014] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1014] = nativeContext.LoadFunction("SDL_strrchr", "SDL3") + ) + )(str, c); - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* Strrchr([NativeTypeName("const char *")] sbyte* str, int c) => + DllImport.Strrchr(str, c); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Strrchr([NativeTypeName("const char *")] Ref str, int c) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Strrchr(__dsl_str, c); + } + } + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrchr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShowWindow(WindowHandle window) => DllImport.ShowWindow(window); + public static Ptr Strrchr([NativeTypeName("const char *")] Ref str, int c) => + DllImport.Strrchr(str, c); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShowWindowRaw(WindowHandle window) => + sbyte* ISdl.Strrev([NativeTypeName("char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[793] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1015] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[793] = nativeContext.LoadFunction("SDL_ShowWindow", "SDL3") + : _slots[1015] = nativeContext.LoadFunction("SDL_strrev", "SDL3") ) - )(window); + )(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindow")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShowWindowRaw(WindowHandle window) => DllImport.ShowWindowRaw(window); + public static sbyte* Strrev([NativeTypeName("char *")] sbyte* str) => DllImport.Strrev(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.ShowWindowSystemMenu(WindowHandle window, int x, int y) => - (MaybeBool)(byte)((ISdl)this).ShowWindowSystemMenuRaw(window, x, y); + Ptr ISdl.Strrev([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Strrev(__dsl_str); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [NativeFunction("SDL3", EntryPoint = "SDL_strrev")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool ShowWindowSystemMenu(WindowHandle window, int x, int y) => - DllImport.ShowWindowSystemMenu(window, x, y); + public static Ptr Strrev([NativeTypeName("char *")] Ref str) => + DllImport.Strrev(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => + sbyte* ISdl.Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => ( - (delegate* unmanaged)( - _slots[794] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1016] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[794] = nativeContext.LoadFunction("SDL_ShowWindowSystemMenu", "SDL3") + : _slots[1016] = nativeContext.LoadFunction("SDL_strstr", "SDL3") ) - )(window, x, y); + )(haystack, needle); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_ShowWindowSystemMenu")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte ShowWindowSystemMenuRaw(WindowHandle window, int x, int y) => - DllImport.ShowWindowSystemMenuRaw(window, x, y); + public static sbyte* Strstr( + [NativeTypeName("const char *")] sbyte* haystack, + [NativeTypeName("const char *")] sbyte* needle + ) => DllImport.Strstr(haystack, needle); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SignalCondition(ConditionHandle cond) => - ( - (delegate* unmanaged)( - _slots[795] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[795] = nativeContext.LoadFunction("SDL_SignalCondition", "SDL3") - ) - )(cond); + Ptr ISdl.Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) + { + fixed (sbyte* __dsl_needle = needle) + fixed (sbyte* __dsl_haystack = haystack) + { + return (sbyte*)((ISdl)this).Strstr(__dsl_haystack, __dsl_needle); + } + } - [NativeFunction("SDL3", EntryPoint = "SDL_SignalCondition")] + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_strstr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SignalCondition(ConditionHandle cond) => DllImport.SignalCondition(cond); + public static Ptr Strstr( + [NativeTypeName("const char *")] Ref haystack, + [NativeTypeName("const char *")] Ref needle + ) => DllImport.Strstr(haystack, needle); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - void ISdl.SignalSemaphore(SemaphoreHandle sem) => + double ISdl.Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ) => ( - (delegate* unmanaged)( - _slots[796] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1017] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[796] = nativeContext.LoadFunction("SDL_SignalSemaphore", "SDL3") + : _slots[1017] = nativeContext.LoadFunction("SDL_strtod", "SDL3") ) - )(sem); + )(str, endp); - [NativeFunction("SDL3", EntryPoint = "SDL_SignalSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static void SignalSemaphore(SemaphoreHandle sem) => DllImport.SignalSemaphore(sem); + public static double Strtod( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp + ) => DllImport.Strtod(str, endp); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StartTextInput(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).StartTextInputRaw(window); + double ISdl.Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (double)((ISdl)this).Strtod(__dsl_str, __dsl_endp); + } + } - [return: NativeTypeName("bool")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtod")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StartTextInput(WindowHandle window) => - DllImport.StartTextInput(window); + public static double Strtod( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp + ) => DllImport.Strtod(str, endp); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StartTextInputRaw(WindowHandle window) => + sbyte* ISdl.StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ) => ( - (delegate* unmanaged)( - _slots[797] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1018] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[797] = nativeContext.LoadFunction("SDL_StartTextInput", "SDL3") + : _slots[1018] = nativeContext.LoadFunction("SDL_strtok_r", "SDL3") ) - )(window); + )(s1, s2, saveptr); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInput")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StartTextInputRaw(WindowHandle window) => - DllImport.StartTextInputRaw(window); + public static sbyte* StrtokR( + [NativeTypeName("char *")] sbyte* s1, + [NativeTypeName("const char *")] sbyte* s2, + [NativeTypeName("char **")] sbyte** saveptr + ) => DllImport.StrtokR(s1, s2, saveptr); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StartTextInputWithProperties( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => (MaybeBool)(byte)((ISdl)this).StartTextInputWithPropertiesRaw(window, props); + Ptr ISdl.StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ) + { + fixed (sbyte** __dsl_saveptr = saveptr) + fixed (sbyte* __dsl_s2 = s2) + fixed (sbyte* __dsl_s1 = s1) + { + return (sbyte*)((ISdl)this).StrtokR(__dsl_s1, __dsl_s2, __dsl_saveptr); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtok_r")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StartTextInputWithProperties( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.StartTextInputWithProperties(window, props); + public static Ptr StrtokR( + [NativeTypeName("char *")] Ref s1, + [NativeTypeName("const char *")] Ref s2, + [NativeTypeName("char **")] Ref2D saveptr + ) => DllImport.StrtokR(s1, s2, saveptr); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StartTextInputWithPropertiesRaw( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props + nint ISdl.Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base ) => ( - (delegate* unmanaged)( - _slots[798] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1019] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[798] = nativeContext.LoadFunction( - "SDL_StartTextInputWithProperties", - "SDL3" - ) + : _slots[1019] = nativeContext.LoadFunction("SDL_strtol", "SDL3") ) - )(window, props); + )(str, endp, @base); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StartTextInputWithProperties")] + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StartTextInputWithPropertiesRaw( - WindowHandle window, - [NativeTypeName("SDL_PropertiesID")] uint props - ) => DllImport.StartTextInputWithPropertiesRaw(window, props); + public static nint Strtol( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => DllImport.Strtol(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StopHapticEffect(HapticHandle haptic, int effect) => - (MaybeBool)(byte)((ISdl)this).StopHapticEffectRaw(haptic, effect); + nint ISdl.Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (nint)((ISdl)this).Strtol(__dsl_str, __dsl_endp, @base); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtol")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StopHapticEffect(HapticHandle haptic, int effect) => - DllImport.StopHapticEffect(haptic, effect); + public static nint Strtol( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => DllImport.Strtol(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StopHapticEffectRaw(HapticHandle haptic, int effect) => + long ISdl.Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => ( - (delegate* unmanaged)( - _slots[799] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1020] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[799] = nativeContext.LoadFunction("SDL_StopHapticEffect", "SDL3") + : _slots[1020] = nativeContext.LoadFunction("SDL_strtoll", "SDL3") ) - )(haptic, effect); + )(str, endp, @base); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffect")] + [return: NativeTypeName("long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StopHapticEffectRaw(HapticHandle haptic, int effect) => - DllImport.StopHapticEffectRaw(haptic, effect); + public static long Strtoll( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => DllImport.Strtoll(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StopHapticEffects(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).StopHapticEffectsRaw(haptic); + long ISdl.Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (long)((ISdl)this).Strtoll(__dsl_str, __dsl_endp, @base); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("long long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoll")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StopHapticEffects(HapticHandle haptic) => - DllImport.StopHapticEffects(haptic); + public static long Strtoll( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => DllImport.Strtoll(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StopHapticEffectsRaw(HapticHandle haptic) => + nuint ISdl.Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => ( - (delegate* unmanaged)( - _slots[800] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1021] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[800] = nativeContext.LoadFunction("SDL_StopHapticEffects", "SDL3") + : _slots[1021] = nativeContext.LoadFunction("SDL_strtoul", "SDL3") ) - )(haptic); + )(str, endp, @base); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticEffects")] + [return: NativeTypeName("unsigned long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StopHapticEffectsRaw(HapticHandle haptic) => - DllImport.StopHapticEffectsRaw(haptic); + public static nuint Strtoul( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => DllImport.Strtoul(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StopHapticRumble(HapticHandle haptic) => - (MaybeBool)(byte)((ISdl)this).StopHapticRumbleRaw(haptic); + nuint ISdl.Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (nuint)((ISdl)this).Strtoul(__dsl_str, __dsl_endp, @base); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("unsigned long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoul")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StopHapticRumble(HapticHandle haptic) => - DllImport.StopHapticRumble(haptic); + public static nuint Strtoul( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => DllImport.Strtoul(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StopHapticRumbleRaw(HapticHandle haptic) => + ulong ISdl.Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => ( - (delegate* unmanaged)( - _slots[801] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1022] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[801] = nativeContext.LoadFunction("SDL_StopHapticRumble", "SDL3") + : _slots[1022] = nativeContext.LoadFunction("SDL_strtoull", "SDL3") ) - )(haptic); + )(str, endp, @base); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopHapticRumble")] + [return: NativeTypeName("unsigned long long")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StopHapticRumbleRaw(HapticHandle haptic) => - DllImport.StopHapticRumbleRaw(haptic); + public static ulong Strtoull( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("char **")] sbyte** endp, + int @base + ) => DllImport.Strtoull(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StopTextInput(WindowHandle window) => - (MaybeBool)(byte)((ISdl)this).StopTextInputRaw(window); + ulong ISdl.Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) + { + fixed (sbyte** __dsl_endp = endp) + fixed (sbyte* __dsl_str = str) + { + return (ulong)((ISdl)this).Strtoull(__dsl_str, __dsl_endp, @base); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("unsigned long long")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [NativeFunction("SDL3", EntryPoint = "SDL_strtoull")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StopTextInput(WindowHandle window) => - DllImport.StopTextInput(window); + public static ulong Strtoull( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("char **")] Ref2D endp, + int @base + ) => DllImport.Strtoull(str, endp, @base); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StopTextInputRaw(WindowHandle window) => + sbyte* ISdl.Strupr([NativeTypeName("char *")] sbyte* str) => ( - (delegate* unmanaged)( - _slots[802] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1023] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[802] = nativeContext.LoadFunction("SDL_StopTextInput", "SDL3") + : _slots[1023] = nativeContext.LoadFunction("SDL_strupr", "SDL3") ) - )(window); + )(str); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StopTextInput")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StopTextInputRaw(WindowHandle window) => DllImport.StopTextInputRaw(window); + public static sbyte* Strupr([NativeTypeName("char *")] sbyte* str) => DllImport.Strupr(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - MaybeBool ISdl.StorageReady(StorageHandle storage) => - (MaybeBool)(byte)((ISdl)this).StorageReadyRaw(storage); + Ptr ISdl.Strupr([NativeTypeName("char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Strupr(__dsl_str); + } + } - [return: NativeTypeName("bool")] + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [NativeFunction("SDL3", EntryPoint = "SDL_strupr")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool StorageReady(StorageHandle storage) => - DllImport.StorageReady(storage); + public static Ptr Strupr([NativeTypeName("char *")] Ref str) => + DllImport.Strupr(str); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.StorageReadyRaw(StorageHandle storage) => - ( - (delegate* unmanaged)( - _slots[803] is not null and var loadedFnPtr - ? loadedFnPtr - : _slots[803] = nativeContext.LoadFunction("SDL_StorageReady", "SDL3") - ) - )(storage); + MaybeBool ISdl.SubmitGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + (MaybeBool)(byte)((ISdl)this).SubmitGPUCommandBufferRaw(command_buffer); [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_StorageReady")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte StorageReadyRaw(StorageHandle storage) => DllImport.StorageReadyRaw(storage); + public static MaybeBool SubmitGPUCommandBuffer(GPUCommandBufferHandle command_buffer) => + DllImport.SubmitGPUCommandBuffer(command_buffer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Guid ISdl.StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => + GPUFenceHandle ISdl.SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ) => ( - (delegate* unmanaged)( - _slots[804] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1025] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[804] = nativeContext.LoadFunction("SDL_StringToGUID", "SDL3") + : _slots[1025] = nativeContext.LoadFunction( + "SDL_SubmitGPUCommandBufferAndAcquireFence", + "SDL3" + ) ) - )(pchGUID); + )(command_buffer); - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBufferAndAcquireFence")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Guid StringToGuid([NativeTypeName("const char *")] sbyte* pchGUID) => - DllImport.StringToGuid(pchGUID); + public static GPUFenceHandle SubmitGPUCommandBufferAndAcquireFence( + GPUCommandBufferHandle command_buffer + ) => DllImport.SubmitGPUCommandBufferAndAcquireFence(command_buffer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - Guid ISdl.StringToGuid([NativeTypeName("const char *")] Ref pchGUID) - { - fixed (sbyte* __dsl_pchGUID = pchGUID) - { - return (Guid)((ISdl)this).StringToGuid(__dsl_pchGUID); - } - } + byte ISdl.SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + ( + (delegate* unmanaged)( + _slots[1024] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1024] = nativeContext.LoadFunction( + "SDL_SubmitGPUCommandBuffer", + "SDL3" + ) + ) + )(command_buffer); - [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_StringToGUID")] + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_SubmitGPUCommandBuffer")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static Guid StringToGuid([NativeTypeName("const char *")] Ref pchGUID) => - DllImport.StringToGuid(pchGUID); + public static byte SubmitGPUCommandBufferRaw(GPUCommandBufferHandle command_buffer) => + DllImport.SubmitGPUCommandBufferRaw(command_buffer); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] byte ISdl.SurfaceHasAlternateImages(Surface* surface) => ( (delegate* unmanaged)( - _slots[805] is not null and var loadedFnPtr + _slots[1026] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[805] = nativeContext.LoadFunction( + : _slots[1026] = nativeContext.LoadFunction( "SDL_SurfaceHasAlternateImages", "SDL3" ) @@ -74904,9 +95868,9 @@ public static MaybeBool SurfaceHasAlternateImages(Ref surface) => byte ISdl.SurfaceHasColorKey(Surface* surface) => ( (delegate* unmanaged)( - _slots[806] is not null and var loadedFnPtr + _slots[1027] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[806] = nativeContext.LoadFunction("SDL_SurfaceHasColorKey", "SDL3") + : _slots[1027] = nativeContext.LoadFunction("SDL_SurfaceHasColorKey", "SDL3") ) )(surface); @@ -74936,9 +95900,9 @@ public static MaybeBool SurfaceHasColorKey(Ref surface) => byte ISdl.SurfaceHasRLE(Surface* surface) => ( (delegate* unmanaged)( - _slots[807] is not null and var loadedFnPtr + _slots[1028] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[807] = nativeContext.LoadFunction("SDL_SurfaceHasRLE", "SDL3") + : _slots[1028] = nativeContext.LoadFunction("SDL_SurfaceHasRLE", "SDL3") ) )(surface); @@ -74977,9 +95941,9 @@ MaybeBool ISdl.SyncWindow(WindowHandle window) => byte ISdl.SyncWindowRaw(WindowHandle window) => ( (delegate* unmanaged)( - _slots[808] is not null and var loadedFnPtr + _slots[1029] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[808] = nativeContext.LoadFunction("SDL_SyncWindow", "SDL3") + : _slots[1029] = nativeContext.LoadFunction("SDL_SyncWindow", "SDL3") ) )(window); @@ -74988,13 +95952,41 @@ _slots[808] is not null and var loadedFnPtr [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] public static byte SyncWindowRaw(WindowHandle window) => DllImport.SyncWindowRaw(window); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Tan(double x) => + ( + (delegate* unmanaged)( + _slots[1030] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1030] = nativeContext.LoadFunction("SDL_tan", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tan")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Tan(double x) => DllImport.Tan(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Tanf(float x) => + ( + (delegate* unmanaged)( + _slots[1031] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1031] = nativeContext.LoadFunction("SDL_tanf", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tanf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Tanf(float x) => DllImport.Tanf(x); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] long ISdl.TellIO(IOStreamHandle context) => ( (delegate* unmanaged)( - _slots[809] is not null and var loadedFnPtr + _slots[1032] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[809] = nativeContext.LoadFunction("SDL_TellIO", "SDL3") + : _slots[1032] = nativeContext.LoadFunction("SDL_TellIO", "SDL3") ) )(context); @@ -75018,9 +96010,9 @@ public static MaybeBool TextInputActive(WindowHandle window) => byte ISdl.TextInputActiveRaw(WindowHandle window) => ( (delegate* unmanaged)( - _slots[810] is not null and var loadedFnPtr + _slots[1033] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[810] = nativeContext.LoadFunction("SDL_TextInputActive", "SDL3") + : _slots[1033] = nativeContext.LoadFunction("SDL_TextInputActive", "SDL3") ) )(window); @@ -75037,9 +96029,9 @@ long ISdl.TimeFromWindows( ) => ( (delegate* unmanaged)( - _slots[811] is not null and var loadedFnPtr + _slots[1034] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[811] = nativeContext.LoadFunction("SDL_TimeFromWindows", "SDL3") + : _slots[1034] = nativeContext.LoadFunction("SDL_TimeFromWindows", "SDL3") ) )(dwLowDateTime, dwHighDateTime); @@ -75059,9 +96051,9 @@ byte ISdl.TimeToDateTime( ) => ( (delegate* unmanaged)( - _slots[812] is not null and var loadedFnPtr + _slots[1035] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[812] = nativeContext.LoadFunction("SDL_TimeToDateTime", "SDL3") + : _slots[1035] = nativeContext.LoadFunction("SDL_TimeToDateTime", "SDL3") ) )(ticks, dt, localTime); @@ -75106,9 +96098,9 @@ void ISdl.TimeToWindows( ) => ( (delegate* unmanaged)( - _slots[813] is not null and var loadedFnPtr + _slots[1036] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[813] = nativeContext.LoadFunction("SDL_TimeToWindows", "SDL3") + : _slots[1036] = nativeContext.LoadFunction("SDL_TimeToWindows", "SDL3") ) )(ticks, dwLowDateTime, dwHighDateTime); @@ -75143,6 +96135,62 @@ public static void TimeToWindows( [NativeTypeName("Uint32 *")] Ref dwHighDateTime ) => DllImport.TimeToWindows(ticks, dwLowDateTime, dwHighDateTime); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Tolower(int x) => + ( + (delegate* unmanaged)( + _slots[1037] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1037] = nativeContext.LoadFunction("SDL_tolower", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_tolower")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Tolower(int x) => DllImport.Tolower(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Toupper(int x) => + ( + (delegate* unmanaged)( + _slots[1038] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1038] = nativeContext.LoadFunction("SDL_toupper", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_toupper")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Toupper(int x) => DllImport.Toupper(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + double ISdl.Trunc(double x) => + ( + (delegate* unmanaged)( + _slots[1039] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1039] = nativeContext.LoadFunction("SDL_trunc", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_trunc")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static double Trunc(double x) => DllImport.Trunc(x); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + float ISdl.Truncf(float x) => + ( + (delegate* unmanaged)( + _slots[1040] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1040] = nativeContext.LoadFunction("SDL_truncf", "SDL3") + ) + )(x); + + [NativeFunction("SDL3", EntryPoint = "SDL_truncf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static float Truncf(float x) => DllImport.Truncf(x); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] MaybeBool ISdl.TryLockMutex(MutexHandle mutex) => (MaybeBool)(byte)((ISdl)this).TryLockMutexRaw(mutex); @@ -75157,9 +96205,9 @@ MaybeBool ISdl.TryLockMutex(MutexHandle mutex) => byte ISdl.TryLockMutexRaw(MutexHandle mutex) => ( (delegate* unmanaged)( - _slots[814] is not null and var loadedFnPtr + _slots[1041] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[814] = nativeContext.LoadFunction("SDL_TryLockMutex", "SDL3") + : _slots[1041] = nativeContext.LoadFunction("SDL_TryLockMutex", "SDL3") ) )(mutex); @@ -75183,9 +96231,9 @@ public static MaybeBool TryLockRWLockForReading(RWLockHandle rwlock) => byte ISdl.TryLockRWLockForReadingRaw(RWLockHandle rwlock) => ( (delegate* unmanaged)( - _slots[815] is not null and var loadedFnPtr + _slots[1042] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[815] = nativeContext.LoadFunction( + : _slots[1042] = nativeContext.LoadFunction( "SDL_TryLockRWLockForReading", "SDL3" ) @@ -75213,9 +96261,9 @@ public static MaybeBool TryLockRWLockForWriting(RWLockHandle rwlock) => byte ISdl.TryLockRWLockForWritingRaw(RWLockHandle rwlock) => ( (delegate* unmanaged)( - _slots[816] is not null and var loadedFnPtr + _slots[1043] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[816] = nativeContext.LoadFunction( + : _slots[1043] = nativeContext.LoadFunction( "SDL_TryLockRWLockForWriting", "SDL3" ) @@ -75232,9 +96280,9 @@ public static byte TryLockRWLockForWritingRaw(RWLockHandle rwlock) => byte ISdl.TryLockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => ( (delegate* unmanaged)( - _slots[817] is not null and var loadedFnPtr + _slots[1044] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[817] = nativeContext.LoadFunction("SDL_TryLockSpinlock", "SDL3") + : _slots[1044] = nativeContext.LoadFunction("SDL_TryLockSpinlock", "SDL3") ) )(@lock); @@ -75265,36 +96313,216 @@ public static MaybeBool TryLockSpinlock( MaybeBool ISdl.TryWaitSemaphore(SemaphoreHandle sem) => (MaybeBool)(byte)((ISdl)this).TryWaitSemaphoreRaw(sem); - [return: NativeTypeName("bool")] + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => + DllImport.TryWaitSemaphore(sem); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.TryWaitSemaphoreRaw(SemaphoreHandle sem) => + ( + (delegate* unmanaged)( + _slots[1045] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1045] = nativeContext.LoadFunction("SDL_TryWaitSemaphore", "SDL3") + ) + )(sem); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => + DllImport.TryWaitSemaphoreRaw(sem); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ) => + ( + (delegate* unmanaged)( + _slots[1046] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1046] = nativeContext.LoadFunction("SDL_UCS4ToUTF8", "SDL3") + ) + )(codepoint, dst); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] sbyte* dst + ) => DllImport.UCS4ToUTF8(codepoint, dst); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ) + { + fixed (sbyte* __dsl_dst = dst) + { + return (sbyte*)((ISdl)this).UCS4ToUTF8(codepoint, __dsl_dst); + } + } + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UCS4ToUTF8")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr UCS4ToUTF8( + [NativeTypeName("Uint32")] uint codepoint, + [NativeTypeName("char *")] Ref dst + ) => DllImport.UCS4ToUTF8(codepoint, dst); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => + ( + (delegate* unmanaged)( + _slots[1047] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1047] = nativeContext.LoadFunction("SDL_uitoa", "SDL3") + ) + )(value, str, radix); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => DllImport.Uitoa(value, str, radix); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Uitoa(value, __dsl_str, radix); + } + } + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_uitoa")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Uitoa( + [NativeTypeName("unsigned int")] uint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Uitoa(value, str, radix); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte* ISdl.Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => + ( + (delegate* unmanaged)( + _slots[1048] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1048] = nativeContext.LoadFunction("SDL_ulltoa", "SDL3") + ) + )(value, str, radix); + + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte* Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => DllImport.Ulltoa(value, str, radix); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Ulltoa(value, __dsl_str, radix); + } + } + + [return: NativeTypeName("char *")] [Transformed] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [NativeFunction("SDL3", EntryPoint = "SDL_ulltoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static MaybeBool TryWaitSemaphore(SemaphoreHandle sem) => - DllImport.TryWaitSemaphore(sem); + public static Ptr Ulltoa( + [NativeTypeName("unsigned long long")] ulong value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Ulltoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - byte ISdl.TryWaitSemaphoreRaw(SemaphoreHandle sem) => + sbyte* ISdl.Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => ( - (delegate* unmanaged)( - _slots[818] is not null and var loadedFnPtr + (delegate* unmanaged)( + _slots[1049] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[818] = nativeContext.LoadFunction("SDL_TryWaitSemaphore", "SDL3") + : _slots[1049] = nativeContext.LoadFunction("SDL_ultoa", "SDL3") ) - )(sem); + )(value, str, radix); - [return: NativeTypeName("bool")] - [NativeFunction("SDL3", EntryPoint = "SDL_TryWaitSemaphore")] + [return: NativeTypeName("char *")] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] - public static byte TryWaitSemaphoreRaw(SemaphoreHandle sem) => - DllImport.TryWaitSemaphoreRaw(sem); + public static sbyte* Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] sbyte* str, + int radix + ) => DllImport.Ultoa(value, str, radix); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ) + { + fixed (sbyte* __dsl_str = str) + { + return (sbyte*)((ISdl)this).Ultoa(value, __dsl_str, radix); + } + } + + [return: NativeTypeName("char *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_ultoa")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Ultoa( + [NativeTypeName("unsigned long")] nuint value, + [NativeTypeName("char *")] Ref str, + int radix + ) => DllImport.Ultoa(value, str, radix); [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] void ISdl.UnbindAudioStream(AudioStreamHandle stream) => ( (delegate* unmanaged)( - _slots[819] is not null and var loadedFnPtr + _slots[1050] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[819] = nativeContext.LoadFunction("SDL_UnbindAudioStream", "SDL3") + : _slots[1050] = nativeContext.LoadFunction("SDL_UnbindAudioStream", "SDL3") ) )(stream); @@ -75307,9 +96535,9 @@ public static void UnbindAudioStream(AudioStreamHandle stream) => void ISdl.UnbindAudioStreams(AudioStreamHandle* streams, int num_streams) => ( (delegate* unmanaged)( - _slots[820] is not null and var loadedFnPtr + _slots[1051] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[820] = nativeContext.LoadFunction("SDL_UnbindAudioStreams", "SDL3") + : _slots[1051] = nativeContext.LoadFunction("SDL_UnbindAudioStreams", "SDL3") ) )(streams, num_streams); @@ -75337,9 +96565,9 @@ public static void UnbindAudioStreams(Ref streams, int num_st void ISdl.UnloadObject(SharedObjectHandle handle) => ( (delegate* unmanaged)( - _slots[821] is not null and var loadedFnPtr + _slots[1052] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[821] = nativeContext.LoadFunction("SDL_UnloadObject", "SDL3") + : _slots[1052] = nativeContext.LoadFunction("SDL_UnloadObject", "SDL3") ) )(handle); @@ -75362,9 +96590,9 @@ public static MaybeBool UnlockAudioStream(AudioStreamHandle stream) => byte ISdl.UnlockAudioStreamRaw(AudioStreamHandle stream) => ( (delegate* unmanaged)( - _slots[822] is not null and var loadedFnPtr + _slots[1053] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[822] = nativeContext.LoadFunction("SDL_UnlockAudioStream", "SDL3") + : _slots[1053] = nativeContext.LoadFunction("SDL_UnlockAudioStream", "SDL3") ) )(stream); @@ -75378,9 +96606,9 @@ public static byte UnlockAudioStreamRaw(AudioStreamHandle stream) => void ISdl.UnlockJoysticks() => ( (delegate* unmanaged)( - _slots[823] is not null and var loadedFnPtr + _slots[1054] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[823] = nativeContext.LoadFunction("SDL_UnlockJoysticks", "SDL3") + : _slots[1054] = nativeContext.LoadFunction("SDL_UnlockJoysticks", "SDL3") ) )(); @@ -75392,9 +96620,9 @@ _slots[823] is not null and var loadedFnPtr void ISdl.UnlockMutex(MutexHandle mutex) => ( (delegate* unmanaged)( - _slots[824] is not null and var loadedFnPtr + _slots[1055] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[824] = nativeContext.LoadFunction("SDL_UnlockMutex", "SDL3") + : _slots[1055] = nativeContext.LoadFunction("SDL_UnlockMutex", "SDL3") ) )(mutex); @@ -75406,9 +96634,9 @@ _slots[824] is not null and var loadedFnPtr void ISdl.UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint props) => ( (delegate* unmanaged)( - _slots[825] is not null and var loadedFnPtr + _slots[1056] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[825] = nativeContext.LoadFunction("SDL_UnlockProperties", "SDL3") + : _slots[1056] = nativeContext.LoadFunction("SDL_UnlockProperties", "SDL3") ) )(props); @@ -75421,9 +96649,9 @@ public static void UnlockProperties([NativeTypeName("SDL_PropertiesID")] uint pr void ISdl.UnlockRWLock(RWLockHandle rwlock) => ( (delegate* unmanaged)( - _slots[826] is not null and var loadedFnPtr + _slots[1057] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[826] = nativeContext.LoadFunction("SDL_UnlockRWLock", "SDL3") + : _slots[1057] = nativeContext.LoadFunction("SDL_UnlockRWLock", "SDL3") ) )(rwlock); @@ -75435,9 +96663,9 @@ _slots[826] is not null and var loadedFnPtr void ISdl.UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] int* @lock) => ( (delegate* unmanaged)( - _slots[827] is not null and var loadedFnPtr + _slots[1058] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[827] = nativeContext.LoadFunction("SDL_UnlockSpinlock", "SDL3") + : _slots[1058] = nativeContext.LoadFunction("SDL_UnlockSpinlock", "SDL3") ) )(@lock); @@ -75465,9 +96693,9 @@ public static void UnlockSpinlock([NativeTypeName("SDL_SpinLock *")] Ref @l void ISdl.UnlockSurface(Surface* surface) => ( (delegate* unmanaged)( - _slots[828] is not null and var loadedFnPtr + _slots[1059] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[828] = nativeContext.LoadFunction("SDL_UnlockSurface", "SDL3") + : _slots[1059] = nativeContext.LoadFunction("SDL_UnlockSurface", "SDL3") ) )(surface); @@ -75493,9 +96721,9 @@ void ISdl.UnlockSurface(Ref surface) void ISdl.UnlockTexture(Texture* texture) => ( (delegate* unmanaged)( - _slots[829] is not null and var loadedFnPtr + _slots[1060] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[829] = nativeContext.LoadFunction("SDL_UnlockTexture", "SDL3") + : _slots[1060] = nativeContext.LoadFunction("SDL_UnlockTexture", "SDL3") ) )(texture); @@ -75517,13 +96745,111 @@ void ISdl.UnlockTexture(Ref texture) [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] public static void UnlockTexture(Ref texture) => DllImport.UnlockTexture(texture); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => + ( + (delegate* unmanaged)( + _slots[1061] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1061] = nativeContext.LoadFunction( + "SDL_UnmapGPUTransferBuffer", + "SDL3" + ) + ) + )(device, transfer_buffer); + + [NativeFunction("SDL3", EntryPoint = "SDL_UnmapGPUTransferBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void UnmapGPUTransferBuffer( + GPUDeviceHandle device, + GPUTransferBufferHandle transfer_buffer + ) => DllImport.UnmapGPUTransferBuffer(device, transfer_buffer); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + ( + (delegate* unmanaged)( + _slots[1062] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1062] = nativeContext.LoadFunction("SDL_unsetenv_unsafe", "SDL3") + ) + )(name); + + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int UnsetenvUnsafe([NativeTypeName("const char *")] sbyte* name) => + DllImport.UnsetenvUnsafe(name); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.UnsetenvUnsafe([NativeTypeName("const char *")] Ref name) + { + fixed (sbyte* __dsl_name = name) + { + return (int)((ISdl)this).UnsetenvUnsafe(__dsl_name); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_unsetenv_unsafe")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int UnsetenvUnsafe([NativeTypeName("const char *")] Ref name) => + DllImport.UnsetenvUnsafe(name); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => + ( + (delegate* unmanaged)( + _slots[1063] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1063] = nativeContext.LoadFunction( + "SDL_UnsetEnvironmentVariable", + "SDL3" + ) + ) + )(env, name); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] sbyte* name + ) => DllImport.UnsetEnvironmentVariable(env, name); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) + { + fixed (sbyte* __dsl_name = name) + { + return (MaybeBool)(byte)((ISdl)this).UnsetEnvironmentVariable(env, __dsl_name); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UnsetEnvironmentVariable")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool UnsetEnvironmentVariable( + EnvironmentHandle env, + [NativeTypeName("const char *")] Ref name + ) => DllImport.UnsetEnvironmentVariable(env, name); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] void ISdl.UpdateGamepads() => ( (delegate* unmanaged)( - _slots[830] is not null and var loadedFnPtr + _slots[1064] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[830] = nativeContext.LoadFunction("SDL_UpdateGamepads", "SDL3") + : _slots[1064] = nativeContext.LoadFunction("SDL_UpdateGamepads", "SDL3") ) )(); @@ -75539,9 +96865,9 @@ byte ISdl.UpdateHapticEffect( ) => ( (delegate* unmanaged)( - _slots[831] is not null and var loadedFnPtr + _slots[1065] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[831] = nativeContext.LoadFunction("SDL_UpdateHapticEffect", "SDL3") + : _slots[1065] = nativeContext.LoadFunction("SDL_UpdateHapticEffect", "SDL3") ) )(haptic, effect, data); @@ -75582,9 +96908,9 @@ public static MaybeBool UpdateHapticEffect( void ISdl.UpdateJoysticks() => ( (delegate* unmanaged)( - _slots[832] is not null and var loadedFnPtr + _slots[1066] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[832] = nativeContext.LoadFunction("SDL_UpdateJoysticks", "SDL3") + : _slots[1066] = nativeContext.LoadFunction("SDL_UpdateJoysticks", "SDL3") ) )(); @@ -75603,9 +96929,9 @@ int UVpitch ) => ( (delegate* unmanaged)( - _slots[833] is not null and var loadedFnPtr + _slots[1067] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[833] = nativeContext.LoadFunction("SDL_UpdateNVTexture", "SDL3") + : _slots[1067] = nativeContext.LoadFunction("SDL_UpdateNVTexture", "SDL3") ) )(texture, rect, Yplane, Ypitch, UVplane, UVpitch); @@ -75666,9 +96992,9 @@ int UVpitch void ISdl.UpdateSensors() => ( (delegate* unmanaged)( - _slots[834] is not null and var loadedFnPtr + _slots[1068] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[834] = nativeContext.LoadFunction("SDL_UpdateSensors", "SDL3") + : _slots[1068] = nativeContext.LoadFunction("SDL_UpdateSensors", "SDL3") ) )(); @@ -75685,9 +97011,9 @@ int pitch ) => ( (delegate* unmanaged)( - _slots[835] is not null and var loadedFnPtr + _slots[1069] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[835] = nativeContext.LoadFunction("SDL_UpdateTexture", "SDL3") + : _slots[1069] = nativeContext.LoadFunction("SDL_UpdateTexture", "SDL3") ) )(texture, rect, pixels, pitch); @@ -75744,9 +97070,9 @@ public static MaybeBool UpdateWindowSurface(WindowHandle window) => byte ISdl.UpdateWindowSurfaceRaw(WindowHandle window) => ( (delegate* unmanaged)( - _slots[836] is not null and var loadedFnPtr + _slots[1070] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[836] = nativeContext.LoadFunction("SDL_UpdateWindowSurface", "SDL3") + : _slots[1070] = nativeContext.LoadFunction("SDL_UpdateWindowSurface", "SDL3") ) )(window); @@ -75764,9 +97090,9 @@ int numrects ) => ( (delegate* unmanaged)( - _slots[837] is not null and var loadedFnPtr + _slots[1071] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[837] = nativeContext.LoadFunction( + : _slots[1071] = nativeContext.LoadFunction( "SDL_UpdateWindowSurfaceRects", "SDL3" ) @@ -75819,9 +97145,9 @@ int Vpitch ) => ( (delegate* unmanaged)( - _slots[838] is not null and var loadedFnPtr + _slots[1072] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[838] = nativeContext.LoadFunction("SDL_UpdateYUVTexture", "SDL3") + : _slots[1072] = nativeContext.LoadFunction("SDL_UpdateYUVTexture", "SDL3") ) )(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); @@ -75887,13 +97213,702 @@ public static MaybeBool UpdateYUVTexture( int Vpitch ) => DllImport.UpdateYUVTexture(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => + ( + (delegate* unmanaged< + GPUCopyPassHandle, + GPUTransferBufferLocation*, + GPUBufferRegion*, + byte, + void>)( + _slots[1073] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1073] = nativeContext.LoadFunction("SDL_UploadToGPUBuffer", "SDL3") + ) + )(copy_pass, source, destination, cycle); + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] GPUTransferBufferLocation* source, + [NativeTypeName("const SDL_GPUBufferRegion *")] GPUBufferRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => DllImport.UploadToGPUBuffer(copy_pass, source, destination, cycle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUBufferRegion* __dsl_destination = destination) + fixed (GPUTransferBufferLocation* __dsl_source = source) + { + ((ISdl)this).UploadToGPUBuffer(copy_pass, __dsl_source, __dsl_destination, (byte)cycle); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUBuffer")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void UploadToGPUBuffer( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTransferBufferLocation *")] + Ref source, + [NativeTypeName("const SDL_GPUBufferRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) => DllImport.UploadToGPUBuffer(copy_pass, source, destination, cycle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => + ( + (delegate* unmanaged< + GPUCopyPassHandle, + GPUTextureTransferInfo*, + GPUTextureRegion*, + byte, + void>)( + _slots[1074] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1074] = nativeContext.LoadFunction("SDL_UploadToGPUTexture", "SDL3") + ) + )(copy_pass, source, destination, cycle); + + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] GPUTextureTransferInfo* source, + [NativeTypeName("const SDL_GPUTextureRegion *")] GPUTextureRegion* destination, + [NativeTypeName("bool")] byte cycle + ) => DllImport.UploadToGPUTexture(copy_pass, source, destination, cycle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) + { + fixed (GPUTextureRegion* __dsl_destination = destination) + fixed (GPUTextureTransferInfo* __dsl_source = source) + { + ((ISdl)this).UploadToGPUTexture( + copy_pass, + __dsl_source, + __dsl_destination, + (byte)cycle + ); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_UploadToGPUTexture")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void UploadToGPUTexture( + GPUCopyPassHandle copy_pass, + [NativeTypeName("const SDL_GPUTextureTransferInfo *")] Ref source, + [NativeTypeName("const SDL_GPUTextureRegion *")] Ref destination, + [NativeTypeName("bool")] MaybeBool cycle + ) => DllImport.UploadToGPUTexture(copy_pass, source, destination, cycle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => + ( + (delegate* unmanaged)( + _slots[1075] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1075] = nativeContext.LoadFunction("SDL_utf8strlcpy", "SDL3") + ) + )(dst, src, dst_bytes); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strlcpy( + [NativeTypeName("char *")] sbyte* dst, + [NativeTypeName("const char *")] sbyte* src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => DllImport.Utf8Strlcpy(dst, src, dst_bytes); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ) + { + fixed (sbyte* __dsl_src = src) + fixed (sbyte* __dsl_dst = dst) + { + return (nuint)((ISdl)this).Utf8Strlcpy(__dsl_dst, __dsl_src, dst_bytes); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlcpy")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strlcpy( + [NativeTypeName("char *")] Ref dst, + [NativeTypeName("const char *")] Ref src, + [NativeTypeName("size_t")] nuint dst_bytes + ) => DllImport.Utf8Strlcpy(dst, src, dst_bytes); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strlen([NativeTypeName("const char *")] sbyte* str) => + ( + (delegate* unmanaged)( + _slots[1076] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1076] = nativeContext.LoadFunction("SDL_utf8strlen", "SDL3") + ) + )(str); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strlen([NativeTypeName("const char *")] sbyte* str) => + DllImport.Utf8Strlen(str); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strlen([NativeTypeName("const char *")] Ref str) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)((ISdl)this).Utf8Strlen(__dsl_str); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strlen([NativeTypeName("const char *")] Ref str) => + DllImport.Utf8Strlen(str); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ) => + ( + (delegate* unmanaged)( + _slots[1077] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1077] = nativeContext.LoadFunction("SDL_utf8strnlen", "SDL3") + ) + )(str, bytes); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strnlen( + [NativeTypeName("const char *")] sbyte* str, + [NativeTypeName("size_t")] nuint bytes + ) => DllImport.Utf8Strnlen(str, bytes); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ) + { + fixed (sbyte* __dsl_str = str) + { + return (nuint)((ISdl)this).Utf8Strnlen(__dsl_str, bytes); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_utf8strnlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Utf8Strnlen( + [NativeTypeName("const char *")] Ref str, + [NativeTypeName("size_t")] nuint bytes + ) => DllImport.Utf8Strnlen(str, bytes); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => + ( + (delegate* unmanaged)( + _slots[1078] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1078] = nativeContext.LoadFunction("SDL_vasprintf", "SDL3") + ) + )(strp, fmt, ap); + + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vasprintf( + [NativeTypeName("char **")] sbyte** strp, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.Vasprintf(strp, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte** __dsl_strp = strp) + { + return (int)((ISdl)this).Vasprintf(__dsl_strp, __dsl_fmt, __dsl_ap); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vasprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vasprintf( + [NativeTypeName("char **")] Ref2D strp, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.Vasprintf(strp, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => + ( + (delegate* unmanaged)( + _slots[1079] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1079] = nativeContext.LoadFunction("SDL_vsnprintf", "SDL3") + ) + )(text, maxlen, fmt, ap); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vsnprintf( + [NativeTypeName("char *")] sbyte* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.Vsnprintf(text, maxlen, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)((ISdl)this).Vsnprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsnprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vsnprintf( + [NativeTypeName("char *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.Vsnprintf(text, maxlen, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => + ( + (delegate* unmanaged)( + _slots[1080] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1080] = nativeContext.LoadFunction("SDL_vsscanf", "SDL3") + ) + )(text, fmt, ap); + + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vsscanf( + [NativeTypeName("const char *")] sbyte* text, + [NativeTypeName("const char *")] sbyte* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.Vsscanf(text, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (sbyte* __dsl_fmt = fmt) + fixed (sbyte* __dsl_text = text) + { + return (int)((ISdl)this).Vsscanf(__dsl_text, __dsl_fmt, __dsl_ap); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vsscanf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vsscanf( + [NativeTypeName("const char *")] Ref text, + [NativeTypeName("const char *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.Vsscanf(text, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => + ( + (delegate* unmanaged)( + _slots[1081] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1081] = nativeContext.LoadFunction("SDL_vswprintf", "SDL3") + ) + )(text, maxlen, fmt, ap); + + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vswprintf( + [NativeTypeName("wchar_t *")] uint* text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] uint* fmt, + [NativeTypeName("va_list")] sbyte* ap + ) => DllImport.Vswprintf(text, maxlen, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) + { + fixed (sbyte* __dsl_ap = ap) + fixed (uint* __dsl_fmt = fmt) + fixed (uint* __dsl_text = text) + { + return (int)((ISdl)this).Vswprintf(__dsl_text, maxlen, __dsl_fmt, __dsl_ap); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_vswprintf")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Vswprintf( + [NativeTypeName("wchar_t *")] Ref text, + [NativeTypeName("size_t")] nuint maxlen, + [NativeTypeName("const wchar_t *")] Ref fmt, + [NativeTypeName("va_list")] Ref ap + ) => DllImport.Vswprintf(text, maxlen, fmt, ap); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ) => + ( + (delegate* unmanaged)( + _slots[1082] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1082] = nativeContext.LoadFunction("SDL_Vulkan_CreateSurface", "SDL3") + ) + )(window, instance, allocator, surface); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator, + [NativeTypeName("VkSurfaceKHR *")] ulong* surface + ) => DllImport.VulkanCreateSurface(window, instance, allocator, surface); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ) + { + fixed (ulong* __dsl_surface = surface) + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte) + ((ISdl)this).VulkanCreateSurface( + window, + __dsl_instance, + __dsl_allocator, + __dsl_surface + ); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_CreateSurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool VulkanCreateSurface( + WindowHandle window, + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator, + [NativeTypeName("VkSurfaceKHR *")] Ref surface + ) => DllImport.VulkanCreateSurface(window, instance, allocator, surface); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ) => + ( + (delegate* unmanaged)( + _slots[1083] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1083] = nativeContext.LoadFunction("SDL_Vulkan_DestroySurface", "SDL3") + ) + )(instance, surface, allocator); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void VulkanDestroySurface( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] void* allocator + ) => DllImport.VulkanDestroySurface(instance, surface, allocator); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ) + { + fixed (void* __dsl_allocator = allocator) + fixed (void* __dsl_instance = instance) + { + ((ISdl)this).VulkanDestroySurface(__dsl_instance, surface, __dsl_allocator); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_DestroySurface")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void VulkanDestroySurface( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkSurfaceKHR")] ulong surface, + [NativeTypeName("const struct VkAllocationCallbacks *")] Ref allocator + ) => DllImport.VulkanDestroySurface(instance, surface, allocator); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + sbyte** ISdl.VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] uint* count) => + ( + (delegate* unmanaged)( + _slots[1084] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1084] = nativeContext.LoadFunction( + "SDL_Vulkan_GetInstanceExtensions", + "SDL3" + ) + ) + )(count); + + [return: NativeTypeName("const char *const *")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static sbyte** VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] uint* count) => + DllImport.VulkanGetInstanceExtensions(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr2D ISdl.VulkanGetInstanceExtensions([NativeTypeName("Uint32 *")] Ref count) + { + fixed (uint* __dsl_count = count) + { + return (sbyte**)((ISdl)this).VulkanGetInstanceExtensions(__dsl_count); + } + } + + [return: NativeTypeName("const char *const *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetInstanceExtensions")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr2D VulkanGetInstanceExtensions( + [NativeTypeName("Uint32 *")] Ref count + ) => DllImport.VulkanGetInstanceExtensions(count); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => + ( + (delegate* unmanaged)( + _slots[1085] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1085] = nativeContext.LoadFunction( + "SDL_Vulkan_GetPresentationSupport", + "SDL3" + ) + ) + )(instance, physicalDevice, queueFamilyIndex); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] void* instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => DllImport.VulkanGetPresentationSupport(instance, physicalDevice, queueFamilyIndex); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) + { + fixed (void* __dsl_instance = instance) + { + return (MaybeBool) + (byte) + ((ISdl)this).VulkanGetPresentationSupport( + __dsl_instance, + physicalDevice, + queueFamilyIndex + ); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetPresentationSupport")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool VulkanGetPresentationSupport( + [NativeTypeName("VkInstance")] Ref instance, + [NativeTypeName("VkPhysicalDevice")] ulong physicalDevice, + [NativeTypeName("Uint32")] uint queueFamilyIndex + ) => DllImport.VulkanGetPresentationSupport(instance, physicalDevice, queueFamilyIndex); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + FunctionPointer ISdl.VulkanGetVkGetInstanceProcAddr() => + ( + (delegate* unmanaged)( + _slots[1086] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1086] = nativeContext.LoadFunction( + "SDL_Vulkan_GetVkGetInstanceProcAddr", + "SDL3" + ) + ) + )(); + + [return: NativeTypeName("SDL_FunctionPointer")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_GetVkGetInstanceProcAddr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static FunctionPointer VulkanGetVkGetInstanceProcAddr() => + DllImport.VulkanGetVkGetInstanceProcAddr(); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + ( + (delegate* unmanaged)( + _slots[1087] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1087] = nativeContext.LoadFunction("SDL_Vulkan_LoadLibrary", "SDL3") + ) + )(path); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte VulkanLoadLibrary([NativeTypeName("const char *")] sbyte* path) => + DllImport.VulkanLoadLibrary(path); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.VulkanLoadLibrary([NativeTypeName("const char *")] Ref path) + { + fixed (sbyte* __dsl_path = path) + { + return (MaybeBool)(byte)((ISdl)this).VulkanLoadLibrary(__dsl_path); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_LoadLibrary")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool VulkanLoadLibrary( + [NativeTypeName("const char *")] Ref path + ) => DllImport.VulkanLoadLibrary(path); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + void ISdl.VulkanUnloadLibrary() => + ( + (delegate* unmanaged)( + _slots[1088] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1088] = nativeContext.LoadFunction("SDL_Vulkan_UnloadLibrary", "SDL3") + ) + )(); + + [NativeFunction("SDL3", EntryPoint = "SDL_Vulkan_UnloadLibrary")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static void VulkanUnloadLibrary() => DllImport.VulkanUnloadLibrary(); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] void ISdl.WaitCondition(ConditionHandle cond, MutexHandle mutex) => ( (delegate* unmanaged)( - _slots[839] is not null and var loadedFnPtr + _slots[1089] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[839] = nativeContext.LoadFunction("SDL_WaitCondition", "SDL3") + : _slots[1089] = nativeContext.LoadFunction("SDL_WaitCondition", "SDL3") ) )(cond, mutex); @@ -75927,9 +97942,9 @@ byte ISdl.WaitConditionTimeoutRaw( ) => ( (delegate* unmanaged)( - _slots[840] is not null and var loadedFnPtr + _slots[1090] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[840] = nativeContext.LoadFunction("SDL_WaitConditionTimeout", "SDL3") + : _slots[1090] = nativeContext.LoadFunction("SDL_WaitConditionTimeout", "SDL3") ) )(cond, mutex, timeoutMS); @@ -75946,9 +97961,9 @@ public static byte WaitConditionTimeoutRaw( byte ISdl.WaitEvent(Event* @event) => ( (delegate* unmanaged)( - _slots[841] is not null and var loadedFnPtr + _slots[1091] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[841] = nativeContext.LoadFunction("SDL_WaitEvent", "SDL3") + : _slots[1091] = nativeContext.LoadFunction("SDL_WaitEvent", "SDL3") ) )(@event); @@ -75976,9 +97991,9 @@ MaybeBool ISdl.WaitEvent(Ref @event) byte ISdl.WaitEventTimeout(Event* @event, [NativeTypeName("Sint32")] int timeoutMS) => ( (delegate* unmanaged)( - _slots[842] is not null and var loadedFnPtr + _slots[1092] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[842] = nativeContext.LoadFunction("SDL_WaitEventTimeout", "SDL3") + : _slots[1092] = nativeContext.LoadFunction("SDL_WaitEventTimeout", "SDL3") ) )(@event, timeoutMS); @@ -76009,13 +98024,139 @@ public static MaybeBool WaitEventTimeout( [NativeTypeName("Sint32")] int timeoutMS ) => DllImport.WaitEventTimeout(@event, timeoutMS); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ) => + ( + (delegate* unmanaged)( + _slots[1093] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1093] = nativeContext.LoadFunction("SDL_WaitForGPUFences", "SDL3") + ) + )(device, wait_all, fences, num_fences); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] byte wait_all, + [NativeTypeName("SDL_GPUFence *const *")] GPUFenceHandle* fences, + [NativeTypeName("Uint32")] uint num_fences + ) => DllImport.WaitForGPUFences(device, wait_all, fences, num_fences); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ) + { + fixed (GPUFenceHandle* __dsl_fences = fences) + { + return (MaybeBool) + (byte) + ((ISdl)this).WaitForGPUFences(device, (byte)wait_all, __dsl_fences, num_fences); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUFences")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool WaitForGPUFences( + GPUDeviceHandle device, + [NativeTypeName("bool")] MaybeBool wait_all, + [NativeTypeName("SDL_GPUFence *const *")] Ref fences, + [NativeTypeName("Uint32")] uint num_fences + ) => DllImport.WaitForGPUFences(device, wait_all, fences, num_fences); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.WaitForGPUIdle(GPUDeviceHandle device) => + (MaybeBool)(byte)((ISdl)this).WaitForGPUIdleRaw(device); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool WaitForGPUIdle(GPUDeviceHandle device) => + DllImport.WaitForGPUIdle(device); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.WaitForGPUIdleRaw(GPUDeviceHandle device) => + ( + (delegate* unmanaged)( + _slots[1094] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1094] = nativeContext.LoadFunction("SDL_WaitForGPUIdle", "SDL3") + ) + )(device); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitForGPUIdle")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte WaitForGPUIdleRaw(GPUDeviceHandle device) => + DllImport.WaitForGPUIdleRaw(device); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ) => + ( + (delegate* unmanaged)( + _slots[1095] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1095] = nativeContext.LoadFunction("SDL_WaitProcess", "SDL3") + ) + )(process, block, exitcode); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] byte block, + int* exitcode + ) => DllImport.WaitProcess(process, block, exitcode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ) + { + fixed (int* __dsl_exitcode = exitcode) + { + return (MaybeBool) + (byte)((ISdl)this).WaitProcess(process, (byte)block, __dsl_exitcode); + } + } + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WaitProcess")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool WaitProcess( + ProcessHandle process, + [NativeTypeName("bool")] MaybeBool block, + Ref exitcode + ) => DllImport.WaitProcess(process, block, exitcode); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] void ISdl.WaitSemaphore(SemaphoreHandle sem) => ( (delegate* unmanaged)( - _slots[843] is not null and var loadedFnPtr + _slots[1096] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[843] = nativeContext.LoadFunction("SDL_WaitSemaphore", "SDL3") + : _slots[1096] = nativeContext.LoadFunction("SDL_WaitSemaphore", "SDL3") ) )(sem); @@ -76045,9 +98186,9 @@ byte ISdl.WaitSemaphoreTimeoutRaw( ) => ( (delegate* unmanaged)( - _slots[844] is not null and var loadedFnPtr + _slots[1097] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[844] = nativeContext.LoadFunction("SDL_WaitSemaphoreTimeout", "SDL3") + : _slots[1097] = nativeContext.LoadFunction("SDL_WaitSemaphoreTimeout", "SDL3") ) )(sem, timeoutMS); @@ -76063,9 +98204,9 @@ public static byte WaitSemaphoreTimeoutRaw( void ISdl.WaitThread(ThreadHandle thread, int* status) => ( (delegate* unmanaged)( - _slots[845] is not null and var loadedFnPtr + _slots[1098] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[845] = nativeContext.LoadFunction("SDL_WaitThread", "SDL3") + : _slots[1098] = nativeContext.LoadFunction("SDL_WaitThread", "SDL3") ) )(thread, status); @@ -76104,9 +98245,9 @@ public static MaybeBool WarpMouseGlobal(float x, float y) => byte ISdl.WarpMouseGlobalRaw(float x, float y) => ( (delegate* unmanaged)( - _slots[846] is not null and var loadedFnPtr + _slots[1099] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[846] = nativeContext.LoadFunction("SDL_WarpMouseGlobal", "SDL3") + : _slots[1099] = nativeContext.LoadFunction("SDL_WarpMouseGlobal", "SDL3") ) )(x, y); @@ -76119,9 +98260,9 @@ _slots[846] is not null and var loadedFnPtr void ISdl.WarpMouseInWindow(WindowHandle window, float x, float y) => ( (delegate* unmanaged)( - _slots[847] is not null and var loadedFnPtr + _slots[1100] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[847] = nativeContext.LoadFunction("SDL_WarpMouseInWindow", "SDL3") + : _slots[1100] = nativeContext.LoadFunction("SDL_WarpMouseInWindow", "SDL3") ) )(window, x, y); @@ -76134,9 +98275,9 @@ public static void WarpMouseInWindow(WindowHandle window, float x, float y) => uint ISdl.WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => ( (delegate* unmanaged)( - _slots[848] is not null and var loadedFnPtr + _slots[1101] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[848] = nativeContext.LoadFunction("SDL_WasInit", "SDL3") + : _slots[1101] = nativeContext.LoadFunction("SDL_WasInit", "SDL3") ) )(flags); @@ -76146,6 +98287,515 @@ _slots[848] is not null and var loadedFnPtr public static uint WasInit([NativeTypeName("SDL_InitFlags")] uint flags) => DllImport.WasInit(flags); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => + ( + (delegate* unmanaged)( + _slots[1102] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1102] = nativeContext.LoadFunction("SDL_wcscasecmp", "SDL3") + ) + )(str1, str2); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcscasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => DllImport.Wcscasecmp(str1, str2); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)((ISdl)this).Wcscasecmp(__dsl_str1, __dsl_str2); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscasecmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcscasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) => DllImport.Wcscasecmp(str1, str2); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => + ( + (delegate* unmanaged)( + _slots[1103] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1103] = nativeContext.LoadFunction("SDL_wcscmp", "SDL3") + ) + )(str1, str2); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcscmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2 + ) => DllImport.Wcscmp(str1, str2); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)((ISdl)this).Wcscmp(__dsl_str1, __dsl_str2); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcscmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcscmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2 + ) => DllImport.Wcscmp(str1, str2); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint* ISdl.Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr) => + ( + (delegate* unmanaged)( + _slots[1104] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1104] = nativeContext.LoadFunction("SDL_wcsdup", "SDL3") + ) + )(wstr); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* Wcsdup([NativeTypeName("const wchar_t *")] uint* wstr) => + DllImport.Wcsdup(wstr); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (uint*)((ISdl)this).Wcsdup(__dsl_wstr); + } + } + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsdup")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Wcsdup([NativeTypeName("const wchar_t *")] Ref wstr) => + DllImport.Wcsdup(wstr); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1105] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1105] = nativeContext.LoadFunction("SDL_wcslcat", "SDL3") + ) + )(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslcat( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcslcat(dst, src, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)((ISdl)this).Wcslcat(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcat")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslcat( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcslcat(dst, src, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1106] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1106] = nativeContext.LoadFunction("SDL_wcslcpy", "SDL3") + ) + )(dst, src, maxlen); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslcpy( + [NativeTypeName("wchar_t *")] uint* dst, + [NativeTypeName("const wchar_t *")] uint* src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcslcpy(dst, src, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_src = src) + fixed (uint* __dsl_dst = dst) + { + return (nuint)((ISdl)this).Wcslcpy(__dsl_dst, __dsl_src, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslcpy")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslcpy( + [NativeTypeName("wchar_t *")] Ref dst, + [NativeTypeName("const wchar_t *")] Ref src, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcslcpy(dst, src, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslen([NativeTypeName("const wchar_t *")] uint* wstr) => + ( + (delegate* unmanaged)( + _slots[1107] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1107] = nativeContext.LoadFunction("SDL_wcslen", "SDL3") + ) + )(wstr); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslen([NativeTypeName("const wchar_t *")] uint* wstr) => + DllImport.Wcslen(wstr); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcslen([NativeTypeName("const wchar_t *")] Ref wstr) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)((ISdl)this).Wcslen(__dsl_wstr); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcslen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcslen([NativeTypeName("const wchar_t *")] Ref wstr) => + DllImport.Wcslen(wstr); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1108] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1108] = nativeContext.LoadFunction("SDL_wcsncasecmp", "SDL3") + ) + )(str1, str2, maxlen); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsncasecmp(str1, str2, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)((ISdl)this).Wcsncasecmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncasecmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcsncasecmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsncasecmp(str1, str2, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1109] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1109] = nativeContext.LoadFunction("SDL_wcsncmp", "SDL3") + ) + )(str1, str2, maxlen); + + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcsncmp( + [NativeTypeName("const wchar_t *")] uint* str1, + [NativeTypeName("const wchar_t *")] uint* str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsncmp(str1, str2, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + int ISdl.Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_str2 = str2) + fixed (uint* __dsl_str1 = str1) + { + return (int)((ISdl)this).Wcsncmp(__dsl_str1, __dsl_str2, maxlen); + } + } + + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsncmp")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int Wcsncmp( + [NativeTypeName("const wchar_t *")] Ref str1, + [NativeTypeName("const wchar_t *")] Ref str2, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsncmp(str1, str2, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1110] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1110] = nativeContext.LoadFunction("SDL_wcsnlen", "SDL3") + ) + )(wstr, maxlen); + + [return: NativeTypeName("size_t")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] uint* wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsnlen(wstr, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nuint ISdl.Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_wstr = wstr) + { + return (nuint)((ISdl)this).Wcsnlen(__dsl_wstr, maxlen); + } + } + + [return: NativeTypeName("size_t")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnlen")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nuint Wcsnlen( + [NativeTypeName("const wchar_t *")] Ref wstr, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsnlen(wstr, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint* ISdl.Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => + ( + (delegate* unmanaged)( + _slots[1111] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1111] = nativeContext.LoadFunction("SDL_wcsnstr", "SDL3") + ) + )(haystack, needle, maxlen); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* Wcsnstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsnstr(haystack, needle, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)((ISdl)this).Wcsnstr(__dsl_haystack, __dsl_needle, maxlen); + } + } + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsnstr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Wcsnstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle, + [NativeTypeName("size_t")] nuint maxlen + ) => DllImport.Wcsnstr(haystack, needle, maxlen); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + uint* ISdl.Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ) => + ( + (delegate* unmanaged)( + _slots[1112] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1112] = nativeContext.LoadFunction("SDL_wcsstr", "SDL3") + ) + )(haystack, needle); + + [return: NativeTypeName("wchar_t *")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static uint* Wcsstr( + [NativeTypeName("const wchar_t *")] uint* haystack, + [NativeTypeName("const wchar_t *")] uint* needle + ) => DllImport.Wcsstr(haystack, needle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + Ptr ISdl.Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ) + { + fixed (uint* __dsl_needle = needle) + fixed (uint* __dsl_haystack = haystack) + { + return (uint*)((ISdl)this).Wcsstr(__dsl_haystack, __dsl_needle); + } + } + + [return: NativeTypeName("wchar_t *")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcsstr")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static Ptr Wcsstr( + [NativeTypeName("const wchar_t *")] Ref haystack, + [NativeTypeName("const wchar_t *")] Ref needle + ) => DllImport.Wcsstr(haystack, needle); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nint ISdl.Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ) => + ( + (delegate* unmanaged)( + _slots[1113] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1113] = nativeContext.LoadFunction("SDL_wcstol", "SDL3") + ) + )(str, endp, @base); + + [return: NativeTypeName("long")] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nint Wcstol( + [NativeTypeName("const wchar_t *")] uint* str, + [NativeTypeName("wchar_t **")] uint** endp, + int @base + ) => DllImport.Wcstol(str, endp, @base); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + nint ISdl.Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ) + { + fixed (uint** __dsl_endp = endp) + fixed (uint* __dsl_str = str) + { + return (nint)((ISdl)this).Wcstol(__dsl_str, __dsl_endp, @base); + } + } + + [return: NativeTypeName("long")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_wcstol")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static nint Wcstol( + [NativeTypeName("const wchar_t *")] Ref str, + [NativeTypeName("wchar_t **")] Ref2D endp, + int @base + ) => DllImport.Wcstol(str, endp, @base); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] MaybeBool ISdl.WindowHasSurface(WindowHandle window) => (MaybeBool)(byte)((ISdl)this).WindowHasSurfaceRaw(window); @@ -76161,9 +98811,9 @@ public static MaybeBool WindowHasSurface(WindowHandle window) => byte ISdl.WindowHasSurfaceRaw(WindowHandle window) => ( (delegate* unmanaged)( - _slots[849] is not null and var loadedFnPtr + _slots[1114] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[849] = nativeContext.LoadFunction("SDL_WindowHasSurface", "SDL3") + : _slots[1114] = nativeContext.LoadFunction("SDL_WindowHasSurface", "SDL3") ) )(window); @@ -76173,6 +98823,101 @@ _slots[849] is not null and var loadedFnPtr public static byte WindowHasSurfaceRaw(WindowHandle window) => DllImport.WindowHasSurfaceRaw(window); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => + (MaybeBool) + (byte)((ISdl)this).WindowSupportsGPUPresentModeRaw(device, window, present_mode); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool WindowSupportsGPUPresentMode( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => DllImport.WindowSupportsGPUPresentMode(device, window, present_mode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => + ( + (delegate* unmanaged)( + _slots[1115] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1115] = nativeContext.LoadFunction( + "SDL_WindowSupportsGPUPresentMode", + "SDL3" + ) + ) + )(device, window, present_mode); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUPresentMode")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte WindowSupportsGPUPresentModeRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUPresentMode present_mode + ) => DllImport.WindowSupportsGPUPresentModeRaw(device, window, present_mode); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + MaybeBool ISdl.WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => + (MaybeBool) + (byte) + ((ISdl)this).WindowSupportsGPUSwapchainCompositionRaw( + device, + window, + swapchain_composition + ); + + [return: NativeTypeName("bool")] + [Transformed] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static MaybeBool WindowSupportsGPUSwapchainComposition( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => DllImport.WindowSupportsGPUSwapchainComposition(device, window, swapchain_composition); + + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + byte ISdl.WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => + ( + (delegate* unmanaged)( + _slots[1116] is not null and var loadedFnPtr + ? loadedFnPtr + : _slots[1116] = nativeContext.LoadFunction( + "SDL_WindowSupportsGPUSwapchainComposition", + "SDL3" + ) + ) + )(device, window, swapchain_composition); + + [return: NativeTypeName("bool")] + [NativeFunction("SDL3", EntryPoint = "SDL_WindowSupportsGPUSwapchainComposition")] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static byte WindowSupportsGPUSwapchainCompositionRaw( + GPUDeviceHandle device, + WindowHandle window, + GPUSwapchainComposition swapchain_composition + ) => DllImport.WindowSupportsGPUSwapchainCompositionRaw(device, window, swapchain_composition); + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] nuint ISdl.WriteIO( IOStreamHandle context, @@ -76181,9 +98926,9 @@ nuint ISdl.WriteIO( ) => ( (delegate* unmanaged)( - _slots[850] is not null and var loadedFnPtr + _slots[1117] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[850] = nativeContext.LoadFunction("SDL_WriteIO", "SDL3") + : _slots[1117] = nativeContext.LoadFunction("SDL_WriteIO", "SDL3") ) )(context, ptr, size); @@ -76236,9 +98981,9 @@ public static MaybeBool WriteS16BE( byte ISdl.WriteS16BERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => ( (delegate* unmanaged)( - _slots[851] is not null and var loadedFnPtr + _slots[1118] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[851] = nativeContext.LoadFunction("SDL_WriteS16BE", "SDL3") + : _slots[1118] = nativeContext.LoadFunction("SDL_WriteS16BE", "SDL3") ) )(dst, value); @@ -76265,9 +99010,9 @@ public static MaybeBool WriteS16LE( byte ISdl.WriteS16LERaw(IOStreamHandle dst, [NativeTypeName("Sint16")] short value) => ( (delegate* unmanaged)( - _slots[852] is not null and var loadedFnPtr + _slots[1119] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[852] = nativeContext.LoadFunction("SDL_WriteS16LE", "SDL3") + : _slots[1119] = nativeContext.LoadFunction("SDL_WriteS16LE", "SDL3") ) )(dst, value); @@ -76294,9 +99039,9 @@ public static MaybeBool WriteS32BE( byte ISdl.WriteS32BERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => ( (delegate* unmanaged)( - _slots[853] is not null and var loadedFnPtr + _slots[1120] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[853] = nativeContext.LoadFunction("SDL_WriteS32BE", "SDL3") + : _slots[1120] = nativeContext.LoadFunction("SDL_WriteS32BE", "SDL3") ) )(dst, value); @@ -76323,9 +99068,9 @@ public static MaybeBool WriteS32LE( byte ISdl.WriteS32LERaw(IOStreamHandle dst, [NativeTypeName("Sint32")] int value) => ( (delegate* unmanaged)( - _slots[854] is not null and var loadedFnPtr + _slots[1121] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[854] = nativeContext.LoadFunction("SDL_WriteS32LE", "SDL3") + : _slots[1121] = nativeContext.LoadFunction("SDL_WriteS32LE", "SDL3") ) )(dst, value); @@ -76352,9 +99097,9 @@ public static MaybeBool WriteS64BE( byte ISdl.WriteS64BERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => ( (delegate* unmanaged)( - _slots[855] is not null and var loadedFnPtr + _slots[1122] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[855] = nativeContext.LoadFunction("SDL_WriteS64BE", "SDL3") + : _slots[1122] = nativeContext.LoadFunction("SDL_WriteS64BE", "SDL3") ) )(dst, value); @@ -76381,9 +99126,9 @@ public static MaybeBool WriteS64LE( byte ISdl.WriteS64LERaw(IOStreamHandle dst, [NativeTypeName("Sint64")] long value) => ( (delegate* unmanaged)( - _slots[856] is not null and var loadedFnPtr + _slots[1123] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[856] = nativeContext.LoadFunction("SDL_WriteS64LE", "SDL3") + : _slots[1123] = nativeContext.LoadFunction("SDL_WriteS64LE", "SDL3") ) )(dst, value); @@ -76410,9 +99155,9 @@ public static MaybeBool WriteS8( byte ISdl.WriteS8Raw(IOStreamHandle dst, [NativeTypeName("Sint8")] sbyte value) => ( (delegate* unmanaged)( - _slots[857] is not null and var loadedFnPtr + _slots[1124] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[857] = nativeContext.LoadFunction("SDL_WriteS8", "SDL3") + : _slots[1124] = nativeContext.LoadFunction("SDL_WriteS8", "SDL3") ) )(dst, value); @@ -76431,9 +99176,9 @@ byte ISdl.WriteStorageFile( ) => ( (delegate* unmanaged)( - _slots[858] is not null and var loadedFnPtr + _slots[1125] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[858] = nativeContext.LoadFunction("SDL_WriteStorageFile", "SDL3") + : _slots[1125] = nativeContext.LoadFunction("SDL_WriteStorageFile", "SDL3") ) )(storage, path, source, length); @@ -76486,9 +99231,9 @@ byte ISdl.WriteSurfacePixel( ) => ( (delegate* unmanaged)( - _slots[859] is not null and var loadedFnPtr + _slots[1126] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[859] = nativeContext.LoadFunction("SDL_WriteSurfacePixel", "SDL3") + : _slots[1126] = nativeContext.LoadFunction("SDL_WriteSurfacePixel", "SDL3") ) )(surface, x, y, r, g, b, a); @@ -76549,9 +99294,12 @@ float a ) => ( (delegate* unmanaged)( - _slots[860] is not null and var loadedFnPtr + _slots[1127] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[860] = nativeContext.LoadFunction("SDL_WriteSurfacePixelFloat", "SDL3") + : _slots[1127] = nativeContext.LoadFunction( + "SDL_WriteSurfacePixelFloat", + "SDL3" + ) ) )(surface, x, y, r, g, b, a); @@ -76617,9 +99365,9 @@ public static MaybeBool WriteU16BE( byte ISdl.WriteU16BERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => ( (delegate* unmanaged)( - _slots[861] is not null and var loadedFnPtr + _slots[1128] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[861] = nativeContext.LoadFunction("SDL_WriteU16BE", "SDL3") + : _slots[1128] = nativeContext.LoadFunction("SDL_WriteU16BE", "SDL3") ) )(dst, value); @@ -76646,9 +99394,9 @@ public static MaybeBool WriteU16LE( byte ISdl.WriteU16LERaw(IOStreamHandle dst, [NativeTypeName("Uint16")] ushort value) => ( (delegate* unmanaged)( - _slots[862] is not null and var loadedFnPtr + _slots[1129] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[862] = nativeContext.LoadFunction("SDL_WriteU16LE", "SDL3") + : _slots[1129] = nativeContext.LoadFunction("SDL_WriteU16LE", "SDL3") ) )(dst, value); @@ -76675,9 +99423,9 @@ public static MaybeBool WriteU32BE( byte ISdl.WriteU32BERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => ( (delegate* unmanaged)( - _slots[863] is not null and var loadedFnPtr + _slots[1130] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[863] = nativeContext.LoadFunction("SDL_WriteU32BE", "SDL3") + : _slots[1130] = nativeContext.LoadFunction("SDL_WriteU32BE", "SDL3") ) )(dst, value); @@ -76704,9 +99452,9 @@ public static MaybeBool WriteU32LE( byte ISdl.WriteU32LERaw(IOStreamHandle dst, [NativeTypeName("Uint32")] uint value) => ( (delegate* unmanaged)( - _slots[864] is not null and var loadedFnPtr + _slots[1131] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[864] = nativeContext.LoadFunction("SDL_WriteU32LE", "SDL3") + : _slots[1131] = nativeContext.LoadFunction("SDL_WriteU32LE", "SDL3") ) )(dst, value); @@ -76733,9 +99481,9 @@ public static MaybeBool WriteU64BE( byte ISdl.WriteU64BERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => ( (delegate* unmanaged)( - _slots[865] is not null and var loadedFnPtr + _slots[1132] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[865] = nativeContext.LoadFunction("SDL_WriteU64BE", "SDL3") + : _slots[1132] = nativeContext.LoadFunction("SDL_WriteU64BE", "SDL3") ) )(dst, value); @@ -76762,9 +99510,9 @@ public static MaybeBool WriteU64LE( byte ISdl.WriteU64LERaw(IOStreamHandle dst, [NativeTypeName("Uint64")] ulong value) => ( (delegate* unmanaged)( - _slots[866] is not null and var loadedFnPtr + _slots[1133] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[866] = nativeContext.LoadFunction("SDL_WriteU64LE", "SDL3") + : _slots[1133] = nativeContext.LoadFunction("SDL_WriteU64LE", "SDL3") ) )(dst, value); @@ -76791,9 +99539,9 @@ public static MaybeBool WriteU8( byte ISdl.WriteU8Raw(IOStreamHandle dst, [NativeTypeName("Uint8")] byte value) => ( (delegate* unmanaged)( - _slots[867] is not null and var loadedFnPtr + _slots[1134] is not null and var loadedFnPtr ? loadedFnPtr - : _slots[867] = nativeContext.LoadFunction("SDL_WriteU8", "SDL3") + : _slots[1134] = nativeContext.LoadFunction("SDL_WriteU8", "SDL3") ) )(dst, value); diff --git a/sources/SDL/SDL/Sdl.gen.cs b/sources/SDL/SDL/Sdl.gen.cs index d4104e359f..d661a08c35 100644 --- a/sources/SDL/SDL/Sdl.gen.cs +++ b/sources/SDL/SDL/Sdl.gen.cs @@ -25,7 +25,7 @@ public partial class ThisThread : ISdl.Static public static void MakeCurrent(ISdl ctx) => Underlying.Value = ctx; } - private readonly unsafe void*[] _slots = new void*[868]; + private readonly unsafe void*[] _slots = new void*[1135]; public static ISdl Instance { get; } = new StaticWrapper(); public static ISdl Create() => Instance; diff --git a/sources/SDL/SDL/SdlContext.cs b/sources/SDL/SDL/SdlContext.cs index 889c02a262..8e3654f550 100644 --- a/sources/SDL/SDL/SdlContext.cs +++ b/sources/SDL/SDL/SdlContext.cs @@ -96,24 +96,40 @@ public SdlContext(WindowHandle window, GLContextStateHandle context, ISdl? sdl = } /// - public bool IsCurrent => Api.GLGetCurrentContext() == Context; + public bool IsCurrent + { + get => Api.GLGetCurrentContext() == Context; + set + { + if (value) + { + Expect(Api.GLMakeCurrent(Window, Context), "make context current"); + } + else + { + Expect(Api.GLMakeCurrent(Window, nullptr), "clear current context"); + } + } + } /// - public void SwapInterval(int interval) => - Expect(Api.GLSetSwapInterval(interval), "set swap interval"); + public int SwapInterval + { + get + { + var interval = 0; + Expect(Api.GLGetSwapInterval(interval.AsRef()), "get swap interval"); + return interval; + } + set => Expect(Api.GLSetSwapInterval(value), "set swap interval"); + } /// public void SwapBuffers() => Expect(Api.GLSwapWindow(Window), "swap buffers"); - /// - public void MakeCurrent() => Expect(Api.GLMakeCurrent(Window, Context), "make context current"); - - /// - public void Clear() => Expect(Api.GLMakeCurrent(Window, nullptr), "clear current context"); - - private void Expect(int ec, string action) + private void Expect(bool ec, string action) { - if (ec is 1) + if (ec) { return; } diff --git a/sources/Windowing/Windowing/DisplayAvailabilityChangeEvent.cs b/sources/Windowing/Windowing/DisplayAvailabilityChangeEvent.cs new file mode 100644 index 0000000000..8e80afa74b --- /dev/null +++ b/sources/Windowing/Windowing/DisplayAvailabilityChangeEvent.cs @@ -0,0 +1,14 @@ +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a display being connected or disconnected. +/// +/// The surface for which display(s) were connected. +/// +/// Old display objects are not guaranteed to be valid or relevant after this event is raised. +/// +// Currently this event does not include the displays that were connected or disconnected. This is primarily because +// there's no clean way to expose such "diffs" from an API perspective (as disconnected IDisplay objects are likely to +// be invalid), and also why would we need to? If a use case arises and this can be implemented in a sound way, let's +// evaluate that then. +public readonly record struct DisplayAvailabilityChangeEvent(Surface Surface); diff --git a/sources/Windowing/Windowing/DisplayChangeEvent.cs b/sources/Windowing/Windowing/DisplayChangeEvent.cs new file mode 100644 index 0000000000..a8b309746c --- /dev/null +++ b/sources/Windowing/Windowing/DisplayChangeEvent.cs @@ -0,0 +1,15 @@ +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a surface changing to a different display. +/// +/// The surface changing to a different display. +/// The display the surface has changed to. +/// +/// It is expected that this event shall be raised for each logically substantial change to the display parameters and +/// this can be defined by each individual platform. For instance, if the underlying platform does not give the +/// application access to any displays other than the one it's currently being displayed on, then it is expected that +/// this event shall be raised if the display changed even if this is represented by the same object. Old display +/// objects are not guaranteed to be valid or relevant after this event is raised. +/// +public readonly record struct DisplayChangeEvent(Surface Surface, IDisplay Display); diff --git a/sources/Windowing/Windowing/DisplayCoordinatesEvent.cs b/sources/Windowing/Windowing/DisplayCoordinatesEvent.cs new file mode 100644 index 0000000000..cb2f5ab04a --- /dev/null +++ b/sources/Windowing/Windowing/DisplayCoordinatesEvent.cs @@ -0,0 +1,21 @@ +namespace Silk.NET.Windowing; + +using Silk.NET.Maths; + +/// +/// Contains properties pertaining to a change in the location and/or size of a display. +/// +/// The surface owning the display. +/// The display for which the location and/or size changed. +/// The previous value of . +/// The new value of . +/// The previous value of . +/// The new value of . +public readonly record struct DisplayCoordinatesEvent( + Surface Surface, + IDisplay Display, + Rectangle OldBounds, + Rectangle NewBounds, + Rectangle OldWorkArea, + Rectangle NewWorkArea +); diff --git a/sources/Windowing/Windowing/DisplayVideoModeAvailabilityChangeEvent.cs b/sources/Windowing/Windowing/DisplayVideoModeAvailabilityChangeEvent.cs new file mode 100644 index 0000000000..1b6aa2ef4c --- /dev/null +++ b/sources/Windowing/Windowing/DisplayVideoModeAvailabilityChangeEvent.cs @@ -0,0 +1,12 @@ +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a change in the available video modes for a display. +/// +/// The surface owning the display. +/// The display for which the video mode availability changed. +// I don't think we need to have a diff here either, why would old video modes be relevant? +public readonly record struct DisplayVideoModeAvailabilityChangeEvent( + Surface Surface, + IDisplay Display +); diff --git a/sources/Windowing/Windowing/IDetachedSurfaceLifecycle.cs b/sources/Windowing/Windowing/IDetachedSurfaceLifecycle.cs new file mode 100644 index 0000000000..ecfc1a2c8e --- /dev/null +++ b/sources/Windowing/Windowing/IDetachedSurfaceLifecycle.cs @@ -0,0 +1,71 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; + +namespace Silk.NET.Windowing; + +/// +/// Represents a surface with a user-controlled lifecycle. +/// +/// +/// This API is not guaranteed to be supported on all platforms and you should only use it if you know what +/// you're doing and know you need the granular control this API provides! Please use +/// instead where possible. If you insist on using this API, please fall back +/// to if returns false indicating a lack +/// of support. +/// +public partial interface IDetachedSurfaceLifecycle : IDisposable +{ + /// + /// Gets the surface with which this lifecycle is associated. The destruction of this surface is handled by + /// the method of this implementation. + /// + Surface Surface { get; } + + /// + /// Gets a value indicating whether the surface is indicating that its lifecycle should conclude as a result of + /// its current configuration e.g. an entire tick passing with being + /// true. + /// + /// + /// It is expected that shall not be called if this property is true. + /// + bool ShouldTerminate => Surface.IsTerminating; + + /// + /// Steps the underlying implementation's surface lifecycle (i.e. event loop), running a single tick on the + /// . + /// + /// + /// It is expected that implementations shall return after doing as little work as possible. For instance, if the + /// underlying implementation exposes one-by-one event retrieval or otherwise allows customisation of the extent to + /// which the event pump is run, it is expected that a single event shall be pumped in this case. Note that this is + /// just an example and the exact details of this is implementation-defined. + /// + void Tick(); + + /// + /// Attempts to create a using the reference implementation. + /// + /// The created surface lifecycle on success, null otherwise. + /// + /// The application that shall be associated with the surface. Note that even with this API, + /// shall still be called for consistency and portability. However, + /// unlike , this method shall not block and will instead return an + /// on which is expected to be continuously called to + /// enact the same behaviour on the surface. The associated application is also used for any additional global + /// configuration, such as . + /// + /// + /// true if has been populated with an + /// object containing a valid , false otherwise. + /// + /// + /// This is the same reference implementation that would otherwise use. + /// + public static sealed partial bool TryCreate( + [NotNullWhen(true)] out IDetachedSurfaceLifecycle? lifecycle + ) + where T : ISurfaceApplication; +} diff --git a/sources/Windowing/Windowing/IDisplay.cs b/sources/Windowing/Windowing/IDisplay.cs new file mode 100644 index 0000000000..b22d7fc34f --- /dev/null +++ b/sources/Windowing/Windowing/IDisplay.cs @@ -0,0 +1,66 @@ +using System.Numerics; + +namespace Silk.NET.Windowing; + +using Silk.NET.Maths; + +/// +/// Represents a display on which a surface can be rendered. +/// +/// +/// Each surface shall get its own object for each display. This is primarily to ensure that +/// users get events dispatched with the surface they expect depending on which the +/// was sourced from. However, display objects can be somewhat shared between all surfaces that +/// share a common ancestor (the "root surface"). Specifically, an object at a given index in +/// on one surface shall be equatable to the object sourced from the same index +/// in on another surface with the same root surface. Furthermore, +/// on one surface shall be assignable to an object +/// sourced from another surface with the same root surface, where shall lookup +/// the equivalent object from its displays upon +/// assignment. +/// +public interface IDisplay : IEquatable +{ + /// + /// Gets the position and resolution of the monitor in screen space. + /// + Rectangle Bounds { get; } + + /// + /// Gets the area within where surfaces are intended to be drawn. + /// + /// + /// This typically is the area left once you account for things like the menu bar and taskbar. + /// + Rectangle WorkArea { get; } + + /// + /// Gets a list of video modes known to be available when this display is . + /// It may be the case that a list of video modes can't be determined until that's the case. Furthermore, if + /// is supported, needs to be + /// to get access to exclusive fullscreen video modes. + /// may be acceptable if the backend supports implicitly switching + /// between windowed and exclusive fullscreen states, but this is not a requirement. + /// + IReadOnlyList? KnownVideoModes { get; } + + /// + /// Gets a value indicating whether the user has designated this display their primary display. + /// + bool IsPrimary { get; } + + /// + /// Gets a colloquial name for the display. This may change, but hopefully not to something the end user won't recognise. + /// + string Description { get; } + + /// + /// An event raised when and/or changes. + /// + event Action? CoordinatesChanged; + + /// + /// An event raised when changes. + /// + event Action? KnownVideoModesChanged; +} diff --git a/sources/Windowing/Windowing/ISurfaceApplication.cs b/sources/Windowing/Windowing/ISurfaceApplication.cs new file mode 100644 index 0000000000..996eb5bfd9 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceApplication.cs @@ -0,0 +1,25 @@ +namespace Silk.NET.Windowing; + +/// +/// Represents an application running within a surface. +/// +public partial interface ISurfaceApplication +{ + /// + /// An optional window class. + /// + static virtual string? WindowClass => null; + + /// + /// Called upon initialization of the application. + /// + static abstract void Initialize(TSurface surface) + where TSurface : Surface; + + /// + /// Runs an application using the reference implementation of Silk.NET.Windowing. + /// + /// The application. + public static sealed partial void Run() + where T : ISurfaceApplication; +} diff --git a/sources/Windowing/Windowing/ISurfaceChildren.cs b/sources/Windowing/Windowing/ISurfaceChildren.cs new file mode 100644 index 0000000000..5cdf671764 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceChildren.cs @@ -0,0 +1,14 @@ +namespace Silk.NET.Windowing; + +/// +/// Provides the ability to spawn children surfaces. +/// +public interface ISurfaceChildren +{ + /// + /// Spawns an application to run within a new child surface. This call shall not block. + /// + /// The application to run within the child surface. + void Spawn() + where T : ISurfaceApplication; +} diff --git a/sources/Windowing/Windowing/ISurfaceDisplay.cs b/sources/Windowing/Windowing/ISurfaceDisplay.cs new file mode 100644 index 0000000000..0159c05974 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceDisplay.cs @@ -0,0 +1,52 @@ +namespace Silk.NET.Windowing; + +/// +/// Provides the ability to configure displays on which the surface can render. +/// +public interface ISurfaceDisplay +{ + /// + /// Gets or sets display on which the surface is currently rendering. If setting, value must be contained in + /// . + /// + IDisplay Current { get; set; } + + /// + /// Gets a list of other displays that this surface can be moved to. If the surface cannot be programmatically moved + /// to another display, it is expected that this shall return a single element list containing + /// . + /// + IReadOnlyList Available { get; } + + /// + /// Gets or sets the video mode with which the surface is being rendered to the display. If setting, value + /// must be contained in . + /// + VideoMode VideoMode { get; set; } + + /// + /// Gets a list of video modes with which the surface can be rendered. If the surface cannot programmatically change + /// its video mode, it is expected that this shall return a single element list containing . + /// + IReadOnlyList AvailableVideoModes { get; } + + /// + /// An event raised when changes. + /// + event Action? CurrentDisplayChanged; + + /// + /// An event raised when changes. + /// + event Action? AvailableChanged; + + /// + /// An event raised when changes. + /// + event Action? AvailableVideoModesChanged; + + /// + /// An event raised when changes. + /// + public event Action? VideoModeChanged; +} diff --git a/sources/Windowing/Windowing/ISurfaceOpenGL.cs b/sources/Windowing/Windowing/ISurfaceOpenGL.cs new file mode 100644 index 0000000000..5af1f66eef --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceOpenGL.cs @@ -0,0 +1,126 @@ +namespace Silk.NET.Windowing; + +using Silk.NET.Maths; + +/// +/// The OpenGL component of a . The methods can only be executed once +/// has executed. +/// +/// +/// These objects may be shared with child windows created using and vice versa i.e. +/// this object can be shared between all surfaces that share a common ancestor (the "root surface"). Beyond that, these +/// objects are not guaranteed to be valid across surfaces. This allows one event handler to enact changes on multiple +/// surfaces. This is important for purposes. +/// +public interface ISurfaceOpenGL : IGLContext +{ + /// + /// Gets or sets a value indicating whether OpenGL support is enabled for this surface. Setting + /// to a value other than will automatically set + /// this property to true, and likewise toggling the value assigned to this property will change the value of + /// . + /// + /// + /// This can only be set during the method. + /// + // Included for consistency with Vulkan. + bool IsEnabled + { + get => Profile != OpenGLContextProfile.None; + set => + Profile = value + ? Profile == OpenGLContextProfile.None + ? OpenGLContextProfile.Default + : Profile + : OpenGLContextProfile.None; + } + + /// + /// Preferred depth buffer bits of the window's framebuffer. + /// + /// + /// Pass null or -1 to use the system default. + /// This can only be set during the method. + /// Setting this property will automatically set to + /// if it is currently . + /// + int? PreferredDepthBufferBits { get; set; } + + /// + /// Preferred stencil buffer bits of the window's framebuffer. + /// + /// + /// Pass null or -1 to use the system default. + /// + int? PreferredStencilBufferBits { get; set; } + + /// + /// Preferred red, green, blue, and alpha bits of the window's framebuffer. + /// + /// + /// Pass null or -1 for any of the channels to use the system default. + /// + Vector4D? PreferredBitDepth { get; set; } + + /// + /// Preferred number of samples for multi-sample anti-aliasing. + /// + /// + /// This can only be set during the method. + /// + int? PreferredSampleCount { get; set; } + + /// + /// The API version to use. + /// + /// + /// This can only be set during the method. + /// + Version32? Version { get; set; } + + /// + /// Flags used to create the OpenGL context. + /// + /// + /// This can only be set during the method. + /// + OpenGLContextFlags Flags { get; set; } + + /// + /// The profile the OpenGL context should use. If is used, the OpenGL + /// component is effectively disabled, allowing for other graphics APIs/components to be used. If any of the other + /// properties on this class are set while this property is , this property + /// shall automatically be populated with the value . + /// + /// + /// This can only be set during the method. If the value is + /// , this shall be replaced with the actual value upon exit from + /// . + /// + OpenGLContextProfile Profile { get; set; } + + /// + /// Gets a value indicating whether the current configuration is supported (e.g. version number). If + /// is not and this property is true, the + /// OpenGL context shall be created and accessible upon exit from + /// . + /// + bool IsSupported { get; } + + /// + /// Gets or sets a value indicating whether the platform should automatically + /// after . Defaults to true. + /// + /// + /// This can be set at any point throughout the surface's execution. + /// + bool ShouldSwapAutomatically { get; set; } + + /// + /// Gets or sets the context with which this context should share resources. + /// + /// + /// This can only be set during the method. + /// + IGLContext? SharedContext { get; set; } +} diff --git a/sources/Windowing/Windowing/ISurfaceScale.cs b/sources/Windowing/Windowing/ISurfaceScale.cs new file mode 100644 index 0000000000..dbdbac0f77 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceScale.cs @@ -0,0 +1,54 @@ +namespace Silk.NET.Windowing; + +/// +/// Provides information pertaining to the surface's graphical scaling. +/// +/// +/// is typically used to scale UI elements to the correct size for the end user. +/// on the other hand is used to scale the entire application to cover the entire client +/// area in cases where the window client size is smaller than the actual drawable size (i.e. it is high density). +/// If scaling content for legibility and scaling the application's rendering as a whole are not needed to be separated, +/// it is recommended to use . Implementations shall always request a high density surface if +/// given the choice, to account for the platforms where applications may not be able to opt-out of high density. +/// +public interface ISurfaceScale +{ + /// + /// Gets the factor with which the application should scale its content to make the content more legible for the + /// user. This has no influence on . + /// + /// + float Content { get; } + + /// + /// Gets the suggested amplification factor when drawing in terms of . This + /// represents the scale from the pixel resolution to the desired content size, and is typically the multiplication + /// of and . + /// + /// + /// For example, if is 2.0 (i.e. there are 2 pixels per screen coordinate) + /// and the window manager requests that applications scale their content up by 2.0 to meet the user's + /// settings as per , this would be 4.0. This is because we're scaling once to + /// account for the fact that the application has twice the amount of pixels available to it for the given window + /// size, and then scaling again so that what we are drawing appears zoomed in as per the user's request. Note that + /// it is rarely the case that an operating system employs both dense pixels and content scale. macOS for + /// instance, instead of setting , opts to scale the resolution in the cases where the + /// user wants magnified visuals instead of having the applications scale their content; whereas Windows sets + /// and instead always keeps as 1.0. This is down + /// to philosophical differences between the window coordinate systems on platforms as to whether they prefer to + /// deal in physical device pixels or physical content sizes. + /// + float Draw { get; } + + /// + /// Gets the ratio of pixels rendered to window size. This shall be equivalent to + /// divided by . + /// + /// + float PixelDensity { get; } + + /// + /// An event raised when any scale factor changes. + /// + public event Action? Changed; +} diff --git a/sources/Windowing/Windowing/ISurfaceVulkan.cs b/sources/Windowing/Windowing/ISurfaceVulkan.cs new file mode 100644 index 0000000000..25bfc8b723 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceVulkan.cs @@ -0,0 +1,37 @@ +namespace Silk.NET.Windowing; + +/// +/// The Vulkan component of a . +/// +public interface ISurfaceVulkan +{ + /// + /// Gets or sets a value indicating whether the Vulkan component is enabled for this surface. + /// + /// + /// This can only be set during the method. + /// + bool IsEnabled { get; set; } + + /// + /// Creates a VkSurface for this surface. + /// + /// + /// The VkInstance to use. Must have extensions specified in enabled. + /// + /// The VkAllocationCallbacks* to use. + /// + /// This can only be executed once the method has returned. + /// + /// The VkSurface. + ulong CreateSurface(nint instance, Ptr allocator); + + /// + /// Gets the instance extensions that are required to be enabled on instances used for . + /// + /// The number of pointers in the return value. + /// + /// The required extensions as a native pointer. The pointer is guaranteed to share the lifetime of the surface. + /// + Ptr2D GetRequiredExtensions(out uint count); +} diff --git a/sources/Windowing/Windowing/ISurfaceWindow.cs b/sources/Windowing/Windowing/ISurfaceWindow.cs new file mode 100644 index 0000000000..79ed3587f7 --- /dev/null +++ b/sources/Windowing/Windowing/ISurfaceWindow.cs @@ -0,0 +1,140 @@ +namespace Silk.NET.Windowing; + +using System.Numerics; +using Silk.NET.Maths; + +/// +/// Represents a window in which a surface is rendering. +/// +public interface ISurfaceWindow +{ + /// + /// Gets the window bounds including the window border. + /// + Rectangle Bounds { get; set; } + + /// + /// Forwards to the component of . + /// + // DIM is required, but this implementation is for illustrative purposes only! Exact resize semantics of silk types + // are yet to be defined. + Vector2 Size + { + get => (Vector2)Bounds.Size; + set => Bounds = Bounds with { Size = new Vector2D(value.X, value.Y) }; + } + + /// + /// Forwards to the component of . + /// + // DIM is required, but this implementation is for illustrative purposes only! Exact resize semantics of silk types + // are yet to be defined. + Vector2 Position + { + get => (Vector2)Bounds.Origin; + set => Bounds = Bounds with { Size = new Vector2D(value.X, value.Y) }; + } + + /// + /// Gets only the inner client area of the window in screen coordinates. For pixels, use + /// or the relevant properties of . + /// + /// + /// Setting this property is interpreted to mean changing by the same delta in the hopes of + /// achieving the desired result. + /// + Rectangle ClientArea { get; set; } + + /// + /// Forwards to the component of . + /// + /// + /// Setting this property is interpreted to mean changing by the same delta in the hopes of + /// achieving the desired result. + /// + Vector2 ClientSize + { + get => (Vector2)ClientArea.Size; + set => ClientArea = ClientArea with { Size = new(value.X, value.Y) }; + } + + /// + /// Raised when and/or changes. + /// + event Action? CoordinatesChanged; + + /// + /// Gets or sets a value indicating whether, unless set to false before the next , + /// the window will close resulting in the irrevocable termination of the surface. Any children active at this point + /// will also be irrevocably terminated, and parent windows should bear this in mind when responding to their + /// events - not rejecting the closure request shall terminate all child surfaces too. + /// + bool IsCloseRequested { get; set; } + + /// + /// Raised when is set to true. + /// + event Action? CloseRequested; + + /// + /// Gets or sets a value indicating whether the window is visible. + /// + bool IsVisible { get; set; } + + /// + /// Raised when changes. + /// + event Action? VisibilityChanged; + + /// + /// Gets or sets a value indicating whether the window currently has input focus. If setting to true, the + /// window will likely be raised atop other windows in order to obtain input focus. Setting to false is not + /// guaranteed to do anything. + /// + bool IsFocused { get; set; } + + /// + /// An event raised when changes. + /// + event Action? FocusChanged; + + /// + /// Gets or sets a title for the window. + /// + string Title { get; set; } + + /// + /// Gets or sets the state of the window within the context of the window manager. This setting can be changed by + /// the user through actions (e.g. the minimise button, maximise, etc). + /// + WindowState State { get; set; } + + /// + /// An event raised when changes. + /// + event Action? StateChanged; + + /// + /// Gets or sets the style of the window border around the client area. + /// + WindowBorder Border { get; set; } + + /// + /// Gets or sets a value indicating whether this window shall be drawn atop all other windows in the window manager. + /// + bool IsTopMost { get; set; } + + /// + /// An event raised when the user drops files onto the window. + /// + event Action? FileDrop; + + /// + /// Sets the window's icon to one of the window icons provided. The icon is selected using an undefined mechanism by + /// the underlying platform, typically taking into account the pixel size of each variant. If no icon variants are + /// provided, then the default icon shall be restored. + /// + /// The window icon variants to set. + /// A value indicating whether the operation was successful. + bool TrySetIcon(WindowIconVariants icon); +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/Helper.cs b/sources/Windowing/Windowing/Implementations/SDL3/Helper.cs new file mode 100644 index 0000000000..089d165634 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/Helper.cs @@ -0,0 +1,90 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +global using static Silk.NET.Windowing.SDL3.Helper; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal static class Helper +{ + private static long _start; + + [Conditional("DEBUG")] + public static void DebugPrint( + string msg = "reached", + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null + ) => + Console.WriteLine( + $"{GetSecs():0000.000000} {path?[(path.LastIndexOf('/') + 1)..]}:{line} {member}: {msg}" + ); + + private static float GetSecs() + { + if (_start == 0) + { + _start = Stopwatch.GetTimestamp(); + } + + return (float)Stopwatch.GetElapsedTime(_start).TotalSeconds; + } + + [Conditional("DEBUG")] + public static void DebugPrintWithError( + string msg, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null + ) => DebugPrint($"{msg} ({Sdl.GetError().ReadToString()})"); + +#pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type + [Conditional("DEBUG")] + public static unsafe void DebugPrintAllProps( + uint props, + [CallerArgumentExpression(nameof(props))] string expr = "props", + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null + ) + { + var state = (expr, path, line, member); + if (Sdl.EnumerateProperties(props, new EnumeratePropertiesCallback(PrintProp), &state) == 1) + { + return; + } + + DebugPrint($"{expr} {props} - failed to enumerate: {Sdl.GetError()}"); + Sdl.ClearError(); + } + + [SuppressMessage("ReSharper", "ExplicitCallerInfoArgument")] + private static unsafe void PrintProp(void* state, uint props, sbyte* propname) + { + var (expr, path, line, member) = *((string?, string?, int, string?)*)state; + DebugPrint( + $"{expr} ({props}) {((Ref)propname).ReadToString()} {Sdl.GetPropertyType(props, propname) switch + { + PropertyType.Pointer => + $"(pointer): {(Ptr)Sdl.GetPointerProperty(props, propname, nullptr)}", + PropertyType.String => + $"(string): {Sdl.GetStringProperty(props, propname, "(default)").ReadToString()}", + PropertyType.Number => + $"(number): {Sdl.GetNumberProperty(props, propname, 0)}", + PropertyType.Float => + $"(float): {Sdl.GetFloatProperty(props, propname, 0)}", + PropertyType.Boolean => + $"(bool): {(bool)Sdl.GetBooleanProperty(props, propname, false)}", + _ => "invalid property", + }}", + path, + line, + member + ); + } +#pragma warning restore CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/IDetachedSurfaceLifecycle.cs b/sources/Windowing/Windowing/Implementations/SDL3/IDetachedSurfaceLifecycle.cs new file mode 100644 index 0000000000..85b2bc5220 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/IDetachedSurfaceLifecycle.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Windowing.SDL3; + +// ReSharper disable once CheckNamespace +namespace Silk.NET.Windowing; + +public partial interface IDetachedSurfaceLifecycle +{ + public static sealed partial bool TryCreate(out IDetachedSurfaceLifecycle? lifecycle) + where T : ISurfaceApplication + { + // TODO figure out if there's a way we can interrogate SDL to figure out the need for SDL_EnterAppMainCallbacks + if ( + OperatingSystem.IsAndroid() + || OperatingSystem.IsBrowser() + || OperatingSystem.IsIOS() + || OperatingSystem.IsMacCatalyst() + || OperatingSystem.IsWasi() + || OperatingSystem.IsTvOS() + || OperatingSystem.IsWatchOS() + || ( + !OperatingSystem.IsWindows() + && !OperatingSystem.IsMacOS() + && !OperatingSystem.IsLinux() + && !OperatingSystem.IsFreeBSD() + ) + ) + { + lifecycle = null; + return false; + } + + lifecycle = new SdlSurfaceLifecycle(SdlSurfaceLifecycle.CoreInit()); + return true; + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/ISurfaceApplication.cs b/sources/Windowing/Windowing/Implementations/SDL3/ISurfaceApplication.cs new file mode 100644 index 0000000000..360b424646 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/ISurfaceApplication.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 Silk.NET.SDL; +using Silk.NET.Windowing.SDL3; + +// ReSharper disable once CheckNamespace +namespace Silk.NET.Windowing; + +public partial interface ISurfaceApplication +{ + public static sealed partial void Run() + where T : ISurfaceApplication + { + Ref arg = (Utf8String)"Silk.NET"u8; + Sdl.EnterAppMainCallbacks( + 1, + arg.AsRef2D(), + SdlSurfaceLifecycle.AppInit(), + SdlSurfaceLifecycle.AppIterate, + SdlSurfaceLifecycle.AppEvent, + SdlSurfaceLifecycle.AppQuit + ); + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlDisplay.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlDisplay.cs new file mode 100644 index 0000000000..aa0d8bad1c --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlDisplay.cs @@ -0,0 +1,176 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal class SdlDisplay : IDisplay +{ + private Rectangle _bounds; + private Rectangle _workArea; + + public SdlDisplay(SdlSurface surface, uint id) + { + Surface = surface; + Id = id; + _bounds = Bounds; + _workArea = WorkArea; + } + + public uint Id { get; } + public SdlSurface Surface { get; } + + public Rectangle Bounds + { + get + { + Rect rect = default; + if (!Sdl.GetDisplayBounds(Id, rect.AsRef())) + { + Sdl.ThrowError(); + } + + return new Rectangle(rect.X, rect.Y, rect.W, rect.H); + } + } + + public Rectangle WorkArea + { + get + { + Rect rect = default; + if (!Sdl.GetDisplayUsableBounds(Id, rect.AsRef())) + { + Sdl.ThrowError(); + } + + return new Rectangle(rect.X, rect.Y, rect.W, rect.H); + } + } + + private VideoMode[]? _silkModes; + + public IReadOnlyList? KnownVideoModes + { + get + { + if (_silkModes is not null) + { + return _silkModes; + } + + UpdateDisplayModes(); + var ret = new VideoMode[_displayModes.Length + 1]; + ret[0] = default; // This is to change back to non-fullscreen. + for (nuint i = 0; (int)i < _displayModes.Length; i++) + { + ref var videoMode = ref _displayModes[i].Handle; + ret[i + 1] = new VideoMode( + (int)(i + 1), + new Vector2(videoMode.W, videoMode.H), + videoMode.RefreshRate + ); + } + + return _silkModes = ret; + } + } + + private Ptr[]? _displayModes; + + internal Ptr[] DisplayModes + { + get + { + if (_displayModes is not null) + { + return _displayModes; + } + + UpdateDisplayModes(); + return _displayModes; + } + } + + [MemberNotNull(nameof(_displayModes))] + private bool UpdateDisplayModes() + { + DebugPrint(); + var count = 0; + var videoModes = Sdl.GetFullscreenDisplayModes(Id, count.AsRef()); + if (videoModes == nullptr) + { + Sdl.ThrowError(); + } + + var span = videoModes.AsSpan(count); + if (_displayModes?.Length == count && span.SequenceEqual(_displayModes)) + { + return false; + } + + var wasNull = _displayModes is null; + _displayModes = new Ptr[count]; + videoModes.AsSpan(count).CopyTo(_displayModes); + Sdl.Free((Ref)videoModes); + _silkModes = null; + if (!wasNull) + { + DebugPrint("Raising KnownVideoModesChanged"); + _knownVideoModesChanged?.Invoke(new DisplayVideoModeAvailabilityChangeEvent()); + } + + return !wasNull; + } + + public bool IsPrimary => Sdl.GetPrimaryDisplay() == Id; + + public string Description => Sdl.GetDisplayName(Id).ReadToString(); + + public event Action? CoordinatesChanged; + private Action? _knownVideoModesChanged; + + public event Action? KnownVideoModesChanged + { + add + { + if (value is null) + { + return; + } + + if (_displayModes is null) + { + UpdateDisplayModes(); + } + + _knownVideoModesChanged += value; + } + remove => _knownVideoModesChanged -= value; + } + + private bool Equals(SdlDisplay other) => Id == other.Id; + + public bool Equals(IDisplay? display) => Equals((object?)display); + + public override bool Equals(object? obj) => + obj is not null + && (ReferenceEquals(this, obj) || (obj.GetType() == GetType() && Equals((SdlDisplay)obj))); + + public override int GetHashCode() => (int)Id; + + public void OnCoordinatesChanged() + { + DebugPrint("Raising CoordinatesChanged..."); + CoordinatesChanged?.Invoke( + new DisplayCoordinatesEvent(Surface, this, _bounds, Bounds, _workArea, WorkArea) + ); + } + + // If _displayModes is null, user doesn't care. + public bool OnModeChanged() => _displayModes is not null && UpdateDisplayModes(); +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlEventProcessor.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlEventProcessor.cs new file mode 100644 index 0000000000..206680b345 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlEventProcessor.cs @@ -0,0 +1,302 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal static class SdlEventProcessor +{ + private static BreakneckLock _lock; + private static uint _emptyEvent; + private static Dictionary? _surfaces; + + // Should be called on the event thread, but given that DeliverEvent can be called on any thread, we need to lock. + public static void AddSurface(uint id, SdlSurface surface) + { + var taken = false; + _lock.Enter(ref taken); + if (!taken) + { + // should never happen + return; + } + + (_surfaces ??= []).Add(id, surface); + _lock.Exit(); + } + + // Should be called on the event thread, but given that DeliverEvent can be called on any thread, we need to lock. + public static void RemoveSurface(uint id) + { + var taken = false; + _lock.Enter(ref taken); + if (!taken) + { + // should never happen + return; + } + + if ((_surfaces?.Remove(id) ?? false) && _surfaces.Count == 0) + { + _surfaces = null; + } + + _lock.Exit(); + } + + // Can be called on any thread + public static void ContinueEvents() + { + var taken = false; + _lock.Enter(ref taken); + if (!taken) + { + // should never happen + return; + } + + if (_emptyEvent == 0) + { + _emptyEvent = Sdl.RegisterEvents(1); + } + + _lock.Exit(); + var @event = new Event { Type = _emptyEvent }; + if (!Sdl.PushEvent(@event.AsRef())) + { + Sdl.ThrowError(); + } + } + + // Can be called on any thread, but for events we recognise we assume that's the event thread + private static List? _droppedFiles; + + public static unsafe void DeliverEvent(ref Event @event) + { + if (_surfaces is null) + { + return; + } + + SdlSurface? surface = null; + if ( + @event.Type is >= (uint)EventType.WindowFirst and <= (uint)EventType.WindowLast + && !_surfaces.TryGetValue(@event.Window.WindowID, out surface) + ) + { + return; + } + + var currentDisplay = 0u; // used to omit a SDL_GetDisplayForWindow lookup in a goto case. + switch (@event.Common.Type) + { + // case (uint)EventType.LocaleChanged: + // case (uint)EventType.SystemThemeChanged: + // case (uint)EventType.DisplayOrientation: + // case (uint)EventType.WindowMouseEnter: + // case (uint)EventType.WindowMouseLeave: + // case (uint)EventType.WindowHitTest: + // case (uint)EventType.WindowIccprofChanged: + // case (uint)EventType.WindowHdrStateChanged: + // case (uint)EventType.WindowSafeAreaChanged: + // case (uint)EventType.WindowOccluded: + // case (uint)EventType.WindowDestroyed: + // case (uint)EventType.DropText: + // case (uint)EventType.DropPosition: + case (uint)EventType.Quit + or (uint)EventType.Terminating: + { + // Treating this as "the root surface(s) is requested to close" - because of the guarantees that + // IsCloseRequested provides regarding the event also applying to children, see the docs for more info. + + var isRequest = + SdlSurfaceComponents.IsWindowEnabled + && @event.Common.Type != (uint)EventType.Terminating; + foreach (var knownSurface in _surfaces.Values) + { + if (knownSurface.Parent is not null) + { + continue; + } + + if (isRequest) + { + knownSurface.Window!.IsCloseRequested = true; + } + else + { + knownSurface.Terminate(); + } + } + + break; + } + case (uint)EventType.LowMemory: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.OnLowMemory(); + } + + break; + } + case (uint)EventType.WillEnterBackground: + // case (uint)EventType.DidEnterBackground: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.OnPausing(); + } + break; + } + case (uint)EventType.WillEnterForeground: + // case (uint)EventType.DidEnterForeground: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.OnResuming(); + } + break; + } + case (uint)EventType.DisplayAdded: + case (uint)EventType.DisplayRemoved: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.Impl.OnAvailableDisplaysChanged(); + } + break; + } + case (uint)EventType.DisplayMoved: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.Impl.OnDisplayCoordinatesChanged(@event.Display.DisplayID); + } + break; + } + case (uint)EventType.DisplayDesktopModeChanged: + case (uint)EventType.DisplayCurrentModeChanged: + case (uint)EventType.DisplayContentScaleChanged: + { + foreach (var knownSurface in _surfaces.Values) + { + knownSurface.Impl.OnPotentialVideoModeChanges( + @event.Display.DisplayID, + out var isDisplayCurrent, + currentDisplay + ); + if (!isDisplayCurrent) + { + continue; + } + + knownSurface.Impl.OnVideoModeChanged(); + knownSurface.Impl.OnPotentialScaleChanges(); + } + break; + } + case (uint)EventType.WindowDisplayScaleChanged: + { + @event = @event with + { + Display = @event.Display with + { + DisplayID = currentDisplay = Sdl.GetDisplayForWindow(surface!.Impl.Handle), + }, + }; + goto case (uint)EventType.DisplayContentScaleChanged; + } + case (uint)EventType.WindowShown when SdlSurfaceComponents.IsWindowEnabled: + case (uint)EventType.WindowHidden when SdlSurfaceComponents.IsWindowEnabled: + // case (uint)EventType.WindowExposed: + { + surface!.Impl.OnVisibilityChanged(@event.Type == (uint)EventType.WindowShown); + break; + } + case (uint)EventType.WindowMoved when SdlSurfaceComponents.IsWindowEnabled: + case (uint)EventType.WindowResized when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowCoordinatesChanged(); + break; + } + // case (uint)EventType.WindowMetalViewResized: + case (uint)EventType.WindowPixelSizeChanged: + { + surface!.OnDrawableSizeChanged(); + break; + } + case (uint)EventType.WindowMinimized when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowStateChanged(WindowState.Minimized); + break; + } + case (uint)EventType.WindowMaximized when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowStateChanged(WindowState.Maximized); + break; + } + case (uint)EventType.WindowRestored when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowStateChanged(WindowState.Normal); + break; + } + case (uint)EventType.WindowFocusGained when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowFocusChanged(true); + break; + } + case (uint)EventType.WindowFocusLost when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.OnWindowFocusChanged(false); + break; + } + case (uint)EventType.WindowCloseRequested when SdlSurfaceComponents.IsWindowEnabled: + { + surface!.Impl.IsCloseRequested = true; + break; + } + case (uint)EventType.WindowDisplayChanged: + { + surface!.Impl.OnCurrentDisplayChanged(); + break; + } + case (uint)EventType.WindowEnterFullscreen: + case (uint)EventType.WindowLeaveFullscreen: + { + // Also takes care of video mode related things. + surface!.Impl.OnWindowStateChanged(); + break; + } + case (uint)EventType.DropBegin: + { + _droppedFiles = []; + break; + } + case (uint)EventType.DropFile: + { + _droppedFiles?.Add((string)(Ptr)@event.Drop.Data); + break; + } + case (uint)EventType.DropComplete: + { + if ( + _droppedFiles is null + || !_surfaces.TryGetValue(@event.Window.WindowID, out surface) + ) + { + _droppedFiles = null; + break; + } + + surface.Impl.OnFileDrop(_droppedFiles); + break; + } + default: + { + return; + } + } + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs new file mode 100644 index 0000000000..4def1f9e7a --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs @@ -0,0 +1,267 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal class SdlSurface : Surface, IDisposable +{ + private bool _isTerminating; + + public SdlSurface() => Impl = new SdlSurfaceComponents(this); + + // This is its own separate class so that users don't inadvertently rely on type system details (i.e. use + // `surface is ISurfaceWindow` instead of `surface.Window`) + internal SdlSurfaceComponents Impl { get; } + internal SdlSurface? Parent { get; set; } + public override ISurfaceOpenGL? OpenGL => SdlSurfaceComponents.IsOpenGLEnabled ? Impl : null; + public override ISurfaceWindow? Window => SdlSurfaceComponents.IsWindowEnabled ? Impl : null; + public override ISurfaceDisplay? Display => SdlSurfaceComponents.IsDisplayEnabled ? Impl : null; + public override ISurfaceVulkan? Vulkan => SdlSurfaceComponents.IsVulkanEnabled ? Impl : null; + public override ISurfaceChildren? Children => + SdlSurfaceComponents.IsChildrenEnabled ? Impl : null; + public override ISurfaceScale? Scale => SdlSurfaceComponents.IsScaleEnabled ? Impl : null; + public override Vector2 DrawableSize => _drawableSize = Impl.DrawableSize; + public override bool IsTerminating => _isTerminating; + public override event Action? DrawableSizeChanged; + public override event Action? Created; + public override event Action? Terminating; + public override event Action? Pausing; + public override event Action? Resuming; + public override event Action? LowMemory; + public override SurfaceTickOptions TickOptions + { + get => default; + set => + throw new NotImplementedException( + "Event-driven main loops are currently not implemented in the underlying library in use by Silk.NET. " + + "See the upstream issue: https://github.com/libsdl-org/SDL/issues/11387" + ); + } + + public void PreInitialize() + { + DebugPrint(); + Impl.PreInitializeSurface(); + } + + public void Initialize() + { + DebugPrint(); + Impl.InitializeSurface(); + DebugPrint("Raising Created..."); + Created?.Invoke(new SurfaceLifecycleEvent(this)); + } + + public override void Continue() => SdlEventProcessor.ContinueEvents(); + + protected internal override void OnTick() + { + Impl.TickChildren(); + base.OnTick(); + } + + public override void Terminate() + { + DebugPrint(); + var prev = _isTerminating; + _isTerminating = true; + if (!prev && _isTerminating) + { + DebugPrint("Recursing into children..."); + Impl.TerminateChildren(); + DebugPrint("Raising Terminating..."); + Terminating?.Invoke(new SurfaceLifecycleEvent(this)); + } + } + + public override bool TryGetPlatformInfo( + [NotNullWhen(true)] out TPlatformInfo? info + ) + where TPlatformInfo : default + { + info = default; + if (!Impl.IsSurfaceInitialized) + { + return false; + } + + var props = Sdl.GetWindowProperties(Impl.Handle); + if (typeof(TPlatformInfo) == typeof(CocoaPlatformInfo)) + { + info = (TPlatformInfo) + (object) + new CocoaPlatformInfo( + (nint) + Sdl.GetPointerProperty(props, Sdl.PropWindowCocoaWindowPointer, nullptr) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(EGLPlatformInfo)) + { + info = (TPlatformInfo) + (object) + new EGLPlatformInfo( + (nint)Sdl.EGLGetCurrentDisplay(), + (nint)Sdl.EGLGetWindowSurface(Impl.Handle) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(UIKitPlatformInfo)) + { + info = (TPlatformInfo) + (object) + new UIKitPlatformInfo( + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowUikitWindowPointer, + nullptr + ), + (uint) + Sdl.GetNumberProperty( + props, + Sdl.PropWindowUikitOpenglFramebufferNumber, + 0 + ), + (uint) + Sdl.GetNumberProperty( + props, + Sdl.PropWindowUikitOpenglRenderbufferNumber, + 0 + ), + (uint) + Sdl.GetNumberProperty( + props, + Sdl.PropWindowUikitOpenglResolveFramebufferNumber, + 0 + ) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(VivantePlatformInfo)) + { + info = (TPlatformInfo) + (object) + new VivantePlatformInfo( + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowVivanteDisplayPointer, + nullptr + ), + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowVivanteWindowPointer, + nullptr + ) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(WaylandPlatformInfo)) + { + info = (TPlatformInfo) + (object) + new WaylandPlatformInfo( + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowWaylandDisplayPointer, + nullptr + ), + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowWaylandDisplayPointer, + nullptr + ) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(Win32PlatformInfo)) + { + info = (TPlatformInfo) + (object) + new Win32PlatformInfo( + (nint) + Sdl.GetPointerProperty(props, Sdl.PropWindowWin32HwndPointer, nullptr), + (nint)Sdl.GetPointerProperty(props, Sdl.PropWindowWin32HdcPointer, nullptr), + (nint) + Sdl.GetPointerProperty( + props, + Sdl.PropWindowWin32InstancePointer, + nullptr + ) + ); + Sdl.ClearError(); + return true; + } + + if (typeof(TPlatformInfo) == typeof(X11PlatformInfo)) + { + info = (TPlatformInfo) + (object) + new X11PlatformInfo( + (nint) + Sdl.GetPointerProperty(props, Sdl.PropWindowX11DisplayPointer, nullptr), + (nint)Sdl.GetNumberProperty(props, Sdl.PropWindowX11WindowNumber, 0) + ); + Sdl.ClearError(); + return true; + } + + return false; + } + + internal void OnPausing() + { + DebugPrint("Raising Pausing..."); + Pausing?.Invoke(new SurfaceLifecycleEvent(this)); + } + + internal void OnResuming() + { + DebugPrint("Raising Resuming..."); + Resuming?.Invoke(new SurfaceLifecycleEvent(this)); + } + + internal void OnLowMemory() + { + DebugPrint("Raising LowMemory..."); + LowMemory?.Invoke(new SurfaceLifecycleEvent(this)); + } + + private Vector2 _drawableSize; + + internal void OnDrawableSizeChanged() + { + var oldDrawableSize = _drawableSize; + var newDrawableSize = DrawableSize; + if (oldDrawableSize != newDrawableSize) + { + DebugPrint("Raising DrawableSizeChanged..."); + DrawableSizeChanged?.Invoke( + new SurfaceResizeEvent(this, oldDrawableSize, newDrawableSize) + ); + } + } + + public void Dispose() => Impl.Dispose(); + + public override unsafe string ToString() => + $"{base.ToString()} (0x{(nint)Impl.Handle.Handle:X})"; +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Children.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Children.cs new file mode 100644 index 0000000000..ef1165df49 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Children.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 Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceChildren +{ + private List? _children; + + public void Spawn() + where T : ISurfaceApplication + { + if (!IsSurfaceInitialized) + { + throw new InvalidOperationException( + "Children cannot be spawned until ISurfaceApplication.Initialize(TSurface) has finished " + + "executing, consider using the Surface.Created callback instead." + ); + } + + _children ??= new List(1); + var child = SdlSurfaceLifecycle.CoreInit(surface); + child.Terminating += _ => + { + _children?.Remove(child); + if (_children?.Count == 0) + { + _children = null; + } + }; + _children.Add(child); + } + + public void TickChildren() + { + if (_children is null) + { + return; + } + + foreach (var child in _children) + { + child.OnTick(); + } + } + + public void TerminateChildren() + { + if (_children is null) + { + return; + } + + foreach (var child in _children) + { + child.Terminate(); + } + } + + private unsafe void InitializeChildren(uint createProps) + { + if ( + surface.Parent is { Impl.Handle.Handle: not null and var handle } + && !Sdl.SetPointerProperty(createProps, Sdl.PropWindowCreateParentPointer, handle) + ) + { + Sdl.ThrowError(); + } + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Display.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Display.cs new file mode 100644 index 0000000000..549f7ac480 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Display.cs @@ -0,0 +1,431 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceDisplay +{ + private SdlDisplay? _display; + private bool CanPositionDetermineDisplay => + IsWindowEnabled + && _state is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen); + + private bool IsDisplayDeterminedByPosition => + CanPositionDetermineDisplay && ClientArea is not ({ Origin.X: -1 } or { Origin.Y: -1 }); + + public IDisplay Current + { + get + { + // If Window decoration is not supported, then the display field is the exclusive determinant of the + // display. Note that if the surface is initialized we defer to SDL to get the most accurate result. + if (!IsSurfaceInitialized && !IsDisplayDeterminedByPosition && _display is { } ret) + { + return ret; + } + + uint current; + if (IsSurfaceInitialized) + { + // Get the most up-to-date value. + current = Sdl.GetDisplayForWindow(Handle); + } + else if (IsDisplayDeterminedByPosition) + { + // Determine the display from the requested position. -1 indicates "don't care" for which _display is + // the determinant. + var ca = ClientArea; + var rect = new Rect + { + X = (int)ca.Origin.X, + Y = (int)ca.Origin.Y, + W = (int)ca.Size.X, + H = (int)ca.Size.Y, + }; + current = Sdl.GetDisplayForRect(rect.AsRef()); + } + else + { + current = Sdl.GetPrimaryDisplay(); + } + + if (current == 0) + { + Sdl.ThrowError(); + } + + foreach (var display in _displays ??= CreateDisplays()) + { + if (display.Id == current) + { + return _display = display; + } + } + + throw new InvalidOperationException( + "Mismatch between displays enumerated from the underlying API and the current display reported by " + + "the underlying API." + ); + } + set + { + var current = Current; + if (value.Equals(current)) + { + return; + } + + SdlDisplay? sdlDisplay = null; + foreach (var display in _displays ??= CreateDisplays()) + { + if (display.Equals(value)) + { + // in case value was from another surface, see IDisplay docs for more info. + // vv---------------------------------------------------------------------- + value = sdlDisplay = display; + break; + } + } + + if (sdlDisplay is null) + { + throw new ArgumentException( + "Display was not one of the Available displays (or that of a related surface).", + nameof(value) + ); + } + + var videoMode = VideoMode; + if (!IsSurfaceInitialized && !IsDisplayDeterminedByPosition) + { + Return(sdlDisplay, videoMode); + return; + } + + if (videoMode == default) // not fullscreen + { + GetPosition(out var x, out var y); + var currentDisplayWorkArea = current.WorkArea; + var newDisplayWorkArea = sdlDisplay.WorkArea; + SetPosition( + (int)(x - currentDisplayWorkArea.Origin.X + newDisplayWorkArea.Origin.X), + (int)(y - currentDisplayWorkArea.Origin.Y + newDisplayWorkArea.Origin.Y) + ); + } + else if ( + IsSurfaceInitialized + && !Sdl.SetWindowFullscreenMode( + Handle, + (Ref)sdlDisplay.DisplayModes[0] + ) + ) + { + Sdl.ThrowError(); + } + + Return(sdlDisplay, videoMode); + return; + void Return(SdlDisplay display, VideoMode vidMode) + { + // If the video mode indicates that we are not exclusive fullscreen, then we keep it as it is. + // Otherwise, we have just changed display and have changed to the first known exclusive video mode. + _videoMode = vidMode == default ? vidMode : display.KnownVideoModes![1]; + var oldDisplay = _display; + _display = display; + + // if oldDisplay is null, we don't have enough confidence to raise an event. + if (!(oldDisplay?.Equals(display) ?? true)) + { + DebugPrint("Raising CurrentDisplayChanged due to a programmatic change..."); + CurrentDisplayChanged?.Invoke(new DisplayChangeEvent(surface, display)); + } + + if ( + _state + is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen) + ) + { + return; + } + + DebugPrint( + "Raising AvailableVideoModes due to current fullscreen display changing..." + ); + AvailableVideoModesChanged?.Invoke( + new DisplayVideoModeAvailabilityChangeEvent(surface, display) + ); + } + + void GetPosition(out int x, out int y) + { + (x, y) = (0, 0); + if (!IsSurfaceInitialized) + { + var ca = ClientArea; + (x, y) = ((int)ca.Origin.X, (int)ca.Origin.Y); + return; + } + + if (!Sdl.GetWindowPosition(Handle, x.AsRef(), y.AsRef())) + { + Sdl.ThrowError(); + } + } + + void SetPosition(int x, int y) + { + if (!IsSurfaceInitialized) + { + ClientArea = ClientArea with { Origin = new Vector2D(x, y) }; + return; + } + + if (!Sdl.SetWindowPosition(Handle, x, y)) + { + Sdl.ThrowError(); + } + } + } + } + + private SdlDisplay[]? _displays; + + public IReadOnlyList Available => _displays ??= CreateDisplays(); + + private SdlDisplay[] CreateDisplays(SdlDisplay[]? reuse = null) + { + var count = 0; + var displays = Sdl.GetDisplays(count.AsRef()); + var ret = new SdlDisplay?[count]; + for (nuint i = 0; (int)i < count; i++) + { + var id = displays[i]; + if (reuse is not null) + { + foreach (var display in reuse) + { + if (display.Id == id) + { + ret[i] = display; + break; + } + } + } + ret[i] ??= new SdlDisplay(surface, id); + } + + Sdl.Free((Ref)displays); + return ret!; + } + + private VideoMode _videoMode; + + public VideoMode VideoMode + { + get + { + if (!IsSurfaceInitialized) + { + return _videoMode; + } + + var displayMode = Sdl.GetWindowFullscreenMode(Handle); + if (displayMode == nullptr) + { + return default; + } + + var display = (SdlDisplay)Current; + for (var i = 0; i < display.DisplayModes.Length; i++) + { + if (display.DisplayModes[i] == displayMode) + { + return _videoMode = display.KnownVideoModes![i + 1]; + } + } + + throw new InvalidOperationException( + "Mismatch between display modes enumerated from the underlying API and the current display mode " + + "reported by the underlying API." + ); + } + set + { + var currentState = State; + if ( + currentState + is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen) + ) + { + if (value != default) + { + ThrowBadVideoMode(nameof(value)); + } + + return; + } + + if ((_videoMode = VideoMode) == value) + { + return; + } + + var display = (SdlDisplay)Current; + var displayMode = GetDisplayMode(display, in value); + SetState( + currentState, + value == default ? WindowState.WindowedFullscreen : WindowState.ExclusiveFullscreen, + (value, displayMode), + display + ); + } + } + + private static void ThrowBadVideoMode(string? arg) => + throw new ArgumentException( + "The given video mode is not one of the AvailableVideoModes.", + arg + ); + + private Ptr GetDisplayMode(SdlDisplay display, in VideoMode value) + { + Ptr displayMode = nullptr; + var found = false; + for (var i = 0; i < display.KnownVideoModes?.Count; i++) + { + if (display.KnownVideoModes[i] != value) + { + continue; + } + + if (i > 0) + { + displayMode = display.DisplayModes[i - 1]; + } + + found = true; + break; + } + + if (!found) + { + ThrowBadVideoMode(nameof(value)); + } + + return displayMode; + } + + public IReadOnlyList AvailableVideoModes => + State is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen) + ? [default] + : Current.KnownVideoModes ?? [default]; + + public event Action? CurrentDisplayChanged; + public event Action? AvailableChanged; + public event Action? AvailableVideoModesChanged; + public event Action? VideoModeChanged; + + internal void OnAvailableDisplaysChanged() + { + if (_displays is not null) + { + // Recreate _displays if it's already created (as this indicates the user is interested in the display + // component). If not, we'll do this next time the user accesses display information. This prevents needless + // work and allocation for something the user may not be interested in. + _displays = CreateDisplays(_displays); + } + + DebugPrint("Raising AvailableChanged..."); + AvailableChanged?.Invoke(new DisplayAvailabilityChangeEvent(surface)); + } + + internal void OnDisplayCoordinatesChanged(uint id) + { + if (_displays is null) + { + // User doesn't care. + return; + } + + foreach (var display in _displays) + { + if (display.Id != id) + { + continue; + } + + display.OnCoordinatesChanged(); + break; + } + } + + // Called for either a desktop mode change or a current mode change. Neither is used to directly raise an event, + // rather this is used as an indicator that the known video modes might've changed to try and raise + // KnownVideoModesChanged. + internal void OnPotentialVideoModeChanges(uint id, out bool isCurrent, uint currentDisplay = 0) + { + var current = currentDisplay == 0 ? Sdl.GetDisplayForWindow(Handle) : currentDisplay; + isCurrent = current == id; + if (_displays is null) + { + // User doesn't care. + return; + } + + foreach (var display in _displays) + { + if (display.Id != id) + { + continue; + } + + if ( + display.OnModeChanged() + && isCurrent + && _state is WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen + ) + { + DebugPrint( + "Raising AvailableVideoModesChanged due to a detected change of KnownVideoModes in the current " + + "fullscreen display..." + ); + AvailableVideoModesChanged?.Invoke( + new DisplayVideoModeAvailabilityChangeEvent(surface, display) + ); + } + + break; + } + } + + public void OnVideoModeChanged() + { + var oldVideoMode = _videoMode; + var newVideoMode = VideoMode; + if (oldVideoMode != newVideoMode) + { + DebugPrint("Raising VideoModeChanged due to a detected change..."); + VideoModeChanged?.Invoke(new VideoModeChangeEvent(surface, newVideoMode)); + } + } + + public void OnCurrentDisplayChanged() => + CurrentDisplayChanged?.Invoke(new DisplayChangeEvent(surface, Current)); + + private void PostInitializeDisplay() + { + if ( + _state == WindowState.ExclusiveFullscreen + && !Sdl.SetWindowFullscreenMode( + Handle, + (Ref)GetDisplayMode((SdlDisplay)Current, in _videoMode) + ) + ) + { + Sdl.ThrowError(); + } + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.OpenGL.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.OpenGL.cs new file mode 100644 index 0000000000..917f51e048 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.OpenGL.cs @@ -0,0 +1,430 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Core.Loader; +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceOpenGL +{ + void IDisposable.Dispose() { } + + public unsafe void* LoadFunction(string functionName, string libraryNameHint) + { + if (ContextHandle != nullptr) + { + return Sdl.GLGetProcAddress(functionName); + } + + ThrowGLPrematureAccessException(); + return null; + } + + private GLContextStateHandle ContextHandle { get; set; } + + public bool IsCurrent + { + get => ContextHandle != nullptr && Sdl.GLGetCurrentContext() == ContextHandle; + set + { + if (ContextHandle == nullptr) + { + ThrowGLPrematureAccessException(); + return; + } + + if (!Sdl.GLMakeCurrent(Handle, value ? ContextHandle : nullptr)) + { + Sdl.ThrowError(); + } + } + } + + private void ThrowGLPrematureAccessException() + { + if (IsSurfaceInitialized) + { + throw new InvalidOperationException( + "The OpenGL context cannot be accessed as it was not enabled during " + + "ISurfaceApplication.Initialize(TSurface)." + ); + } + throw new InvalidOperationException( + "The OpenGL context cannot be accessed until ISurfaceApplication.Initialize(TSurface) " + + "has finished executing, consider using the Surface.Created callback instead." + ); + } + + public int SwapInterval + { + get + { + if (ContextHandle == nullptr) + { + return field; + } + + var ret = 0; + if (!Sdl.GLGetSwapInterval(ret.AsRef())) + { + Sdl.ThrowError(); + } + + return field = ret; + } + set + { + if (ContextHandle == nullptr) + { + field = value; + SetEnabled(); + return; + } + + if (!Sdl.GLSetSwapInterval(value)) + { + Sdl.ThrowError(); + } + field = value; + } + } + + public void SwapBuffers() + { + if (!Sdl.GLSwapWindow(Handle)) + { + Sdl.ThrowError(); + } + } + + public int? PreferredDepthBufferBits + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public int? PreferredStencilBufferBits + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public Vector4D? PreferredBitDepth + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public int? PreferredSampleCount + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public Version32? Version + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public OpenGLContextFlags Flags + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + public OpenGLContextProfile Profile + { + get; + set + { + AssertUninit(); + field = value; + } + } + + public bool IsSupported => TryCreateContext(false); + + public bool ShouldSwapAutomatically { get; set; } = true; + + public IGLContext? SharedContext + { + get; + set + { + AssertUninit(); + SetEnabled(); + field = value; + } + } + + private void SetEnabled() + { + if (Profile == OpenGLContextProfile.None) + { + Profile = OpenGLContextProfile.Default; + } + } + + private bool TryCreateContext(bool isInitializing) + { + var profile = Profile; + if (profile is OpenGLContextProfile.None) + { + return true; + } + + // If isInitializing == false, we should restore the thread to the state we found it in. + var current = Sdl.GLGetCurrentContext(); + WindowHandle currentWindow = nullptr; + if (current != nullptr) + { + currentWindow = Sdl.GLGetCurrentWindow(); + } + + if (Handle == nullptr && isInitializing) + { + throw new InvalidOperationException( + "Attempted to initialize OpenGL context before window initialization - this should not be possible " + + "with normal usage. Please report this at https://github.com/dotnet/Silk.NET" + ); + } + + // We need to create a dummy window if we haven't already (InitializePlatform does this, but it's only made + // available to the first Surface). This is assigned to Handle if successful. + if ( + !isInitializing + && GetDummyWindow(Sdl.WindowOpengl, nFlags: Sdl.WindowVulkan) == nullptr + ) + { + // Guess OpenGL isn't supported after all... + ClearErrorIf(!isInitializing); + return false; + } + + // Get the shared context we need to make current before creating the context + (GLContextStateHandle Context, WindowHandle Window)? sharedContext = ( + (ISurfaceOpenGL)this + ).SharedContext switch + { + SdlContext sdlCtx => (sdlCtx.Context, sdlCtx.Window), + SdlSurfaceComponents impl => (impl.ContextHandle, impl.Handle), + not null => (nullptr, nullptr), + _ => null, + }; + + // If SharedContext is set to some type we don't recognise, fail. + if (sharedContext?.Context == nullptr) + { + if (isInitializing) + { + throw new NotSupportedException( + "On this platform, SharedContext must be either a Silk.NET.SDL.SdlContext an OpenGL component " + + "retrieved from a surface created using ISurfaceApplication.Run() or " + + "IDetachedSurfaceLifecycle.TryCreate(out IDetachedSurfaceLifecycle?)." + ); + } + return false; + } + + // Ensure that the current context is either the context we want to share with or empty. + var expectedCurrentWindow = sharedContext?.Window ?? Handle; + var expectedCurrent = sharedContext?.Context ?? nullptr; + if (current != expectedCurrent || currentWindow != expectedCurrentWindow) + { + Sdl.GLMakeCurrent(sharedContext?.Window ?? Handle, sharedContext?.Context ?? nullptr); + } + + if (sharedContext is not null && !Sdl.GLSetAttribute(GLAttr.ShareWithCurrentContext, 1)) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Set the context profile. + if ( + profile is not OpenGLContextProfile.Default + && !Sdl.GLSetAttribute( + GLAttr.ContextProfileMask, + profile switch + { + OpenGLContextProfile.Core => Sdl.GlContextProfileCore, + OpenGLContextProfile.Compatibility => Sdl.GlContextProfileCompatibility, + OpenGLContextProfile.ES2 => Sdl.GlContextProfileEs, + _ => throw new InvalidOperationException( + "OpenGLContextProfile is not a legal value." + ), + } + ) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Set the context flags. + var flags = Flags; + if ( + flags is not OpenGLContextFlags.Default + && !Sdl.GLSetAttribute( + GLAttr.ContextProfileMask, + ((flags & OpenGLContextFlags.Debug) != 0 ? Sdl.GlContextDebugFlag : 0) + | ( + (flags & OpenGLContextFlags.ForwardCompatible) != 0 + ? Sdl.GlContextForwardCompatibleFlag + : 0 + ) + ) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Set the specific version requested, if applicable. + if ( + Version is { } ver + && !( + Sdl.GLSetAttribute(GLAttr.ContextMajorVersion, (int)ver.Major) + && Sdl.GLSetAttribute(GLAttr.ContextMinorVersion, (int)ver.Minor) + ) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Set the bit depth. + if ( + PreferredBitDepth is { } colour + && !( + (colour.X < 0 || Sdl.GLSetAttribute(GLAttr.RedSize, colour.X)) + && (colour.Y < 0 || Sdl.GLSetAttribute(GLAttr.GreenSize, colour.Y)) + && (colour.Z < 0 || Sdl.GLSetAttribute(GLAttr.BlueSize, colour.Z)) + && (colour.W < 0 || Sdl.GLSetAttribute(GLAttr.AlphaSize, colour.W)) + ) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Configure MSAA. + if ( + PreferredSampleCount is >= 0 and var count + && !( + Sdl.GLSetAttribute(GLAttr.Multisamplebuffers, 1) + && Sdl.GLSetAttribute(GLAttr.Multisamplesamples, count) + ) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Configure depth buffer. + if (PreferredDepthBufferBits is { } depth && !Sdl.GLSetAttribute(GLAttr.DepthSize, depth)) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Configure stencil buffer. + if ( + PreferredStencilBufferBits is { } stencil + && !Sdl.GLSetAttribute(GLAttr.StencilSize, stencil) + ) + { + ClearErrorIf(!isInitializing); + return false; + } + + // Now let's try to create the context! + var ctx = Sdl.GLCreateContext(Handle); + if (ctx == nullptr) + { + ClearErrorIf(!isInitializing); + return false; + } + + // If successful, we should update our state if we're initializing. If we're not initializing, then we simply + // destroy the context (as sadly that's the only way we can check whether a given configuration is supported). + if (isInitializing) + { + var swapInterval = SwapInterval; + ContextHandle = ctx; + SwapInterval = swapInterval; + return true; + } + + if (!Sdl.GLMakeCurrent(currentWindow, current)) + { + Sdl.ThrowError(); + } + + if (!Sdl.GLDestroyContext(ctx)) + { + Sdl.ThrowError(); + } + + return true; + static void ClearErrorIf(bool value) + { + if (value) + { + Sdl.ClearError(); + } + } + } + + private void InitializeOpenGL(uint props) + { + if (Profile == OpenGLContextProfile.None) + { + return; + } + + AddWindowCreateFlags(props, Sdl.WindowOpengl); + } + + private void PostInitializeOpenGL() + { + DebugPrint(); + if (!TryCreateContext(true)) + { + Sdl.ThrowError(); + } + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Scale.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Scale.cs new file mode 100644 index 0000000000..d1099114f6 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Scale.cs @@ -0,0 +1,106 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Numerics; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceScale +{ + private float _contentScale, + _drawScale, + _pixelDensity; + public float Content => + IsSurfaceInitialized + ? _contentScale = Sdl.GetDisplayContentScale(Sdl.GetDisplayForWindow(Handle)) + : default; + + public float Draw => + IsSurfaceInitialized ? _drawScale = Sdl.GetWindowDisplayScale(Handle) : default; + + public float PixelDensity => + IsSurfaceInitialized ? _pixelDensity = Sdl.GetWindowPixelDensity(Handle) : default; + + event Action? ISurfaceScale.Changed + { + add + { + if (ScaleChanged is null) + { + _contentScale = Content; + _drawScale = Draw; + _pixelDensity = PixelDensity; + } + + ScaleChanged += value; + } + remove => ScaleChanged -= value; + } + + private event Action? ScaleChanged; + + public Vector2 DrawableSize + { + get + { + if (!IsSurfaceInitialized) + { + return default; + } + + var w = 0; + var h = 0; + if (!Sdl.GetWindowSizeInPixels(Handle, w.AsRef(), h.AsRef())) + { + Sdl.ThrowError(); + } + return new Vector2(w, h); + } + } + + public void OnPotentialScaleChanges() + { + if (ScaleChanged is null) + { + // User doesn't care. + return; + } + + var oldContent = _contentScale; + var newContent = _contentScale; + var oldDraw = _drawScale; + var newDraw = Draw; + var oldPixelDensity = _pixelDensity; + var newPixelDensity = PixelDensity; + if ( + MathF.Abs(oldContent - newContent) > float.Epsilon + || MathF.Abs(oldDraw - newDraw) > float.Epsilon + || MathF.Abs(oldPixelDensity - newPixelDensity) > float.Epsilon + ) + { + DebugPrint("Raising ScaleChanged..."); + ScaleChanged?.Invoke( + new ScaleChangedEvent( + surface, + oldContent, + newContent, + oldDraw, + newDraw, + oldPixelDensity, + newPixelDensity + ) + ); + } + } + + private void InitializeScale(uint createProps) + { + if (!Sdl.SetBooleanProperty(createProps, Sdl.PropWindowCreateHighPixelDensityBoolean, true)) + { + Sdl.ThrowError(); + } + } + + private void PostInitializeScale() => OnPotentialScaleChanges(); +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Vulkan.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Vulkan.cs new file mode 100644 index 0000000000..e3bf268db0 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Vulkan.cs @@ -0,0 +1,73 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceVulkan +{ + bool ISurfaceVulkan.IsEnabled + { + get => IsVulkanConfigured; + set => IsVulkanConfigured = value; + } + private bool IsVulkanConfigured + { + get; + set + { + AssertUninit(); + field = value; + } + } + + private static void ThrowVulkanPrematureAccessException() => + throw new InvalidOperationException( + "The Vulkan component cannot be accessed until ISurfaceApplication.Initialize(TSurface) " + + "has finished executing, consider using the Surface.Created callback instead." + ); + + public unsafe ulong CreateSurface(IntPtr instance, Ptr allocator) + { + if (!IsSurfaceInitialized) + { + ThrowVulkanPrematureAccessException(); + } + + var ret = 0ul; + if (!Sdl.VulkanCreateSurface(Handle, (void*)instance, allocator, ret.AsRef())) + { + Sdl.ThrowError(); + } + + return ret; + } + + public Ptr2D GetRequiredExtensions(out uint count) + { + if (!IsSurfaceInitialized) + { + ThrowVulkanPrematureAccessException(); + } + + count = 0; + var exts = Sdl.VulkanGetInstanceExtensions(count.AsRef()); + if (exts == nullptr) + { + Sdl.ThrowError(); + } + + return exts; + } + + private void InitializeVulkan(uint props) + { + if (!IsVulkanConfigured) + { + return; + } + + AddWindowCreateFlags(props, Sdl.WindowVulkan); + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Window.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Window.cs new file mode 100644 index 0000000000..b67a043fb6 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Window.cs @@ -0,0 +1,665 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Reflection; +using System.Runtime.CompilerServices; +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal partial class SdlSurfaceComponents : ISurfaceWindow +{ + private Rectangle _bounds; + public Rectangle Bounds + { + get => GetBounds(ClientArea); + set + { + var top = 0; + var left = 0; + var bottom = 0; + var right = 0; + if ( + IsSurfaceInitialized + && !Sdl.GetWindowBordersSize( + Handle, + top.AsRef(), + left.AsRef(), + bottom.AsRef(), + right.AsRef() + ) + ) + { + Sdl.ThrowError(); + } + + ClientArea = new Rectangle( + value.Origin.X + left, + value.Origin.Y - top, + value.Size.X - left - right, + value.Size.Y - top - bottom + ); + _bounds = value; + } + } + + private Rectangle GetBounds(Rectangle ca) + { + if (!IsSurfaceInitialized) + { + return _bounds = ca; + } + + var top = 0; + var left = 0; + var bottom = 0; + var right = 0; + if ( + !Sdl.GetWindowBordersSize( + Handle, + top.AsRef(), + left.AsRef(), + bottom.AsRef(), + right.AsRef() + ) + ) + { + Sdl.ClearError(); + } + + return _bounds = new Rectangle( + ca.Origin.X - left, + ca.Origin.Y + top, + ca.Size.X + left + right, + ca.Size.Y + top + bottom + ); + } + + private Rectangle _clientArea = new(-1, -1, 640, 480); + public Rectangle ClientArea + { + get + { + if (!IsSurfaceInitialized) + { + return _clientArea; + } + + var x = 0; + var y = 0; + var width = 0; + var height = 0; + if (!Sdl.GetWindowPosition(Handle, x.AsRef(), y.AsRef())) + { + Sdl.ThrowError(); + } + + if (!Sdl.GetWindowSize(Handle, width.AsRef(), height.AsRef())) + { + Sdl.ThrowError(); + } + + return _clientArea = new Rectangle(x, y, width, height); + } + set + { + if (!IsSurfaceInitialized) + { + OnWindowCoordinatesChanged(value); + return; + } + + var x = (int)value.Origin.X; + var y = (int)value.Origin.Y; + var currentDisplay = 0u; + CheckForDontCare(ref x, ref currentDisplay); + CheckForDontCare(ref y, ref currentDisplay); + if ( + !Sdl.SetWindowPosition(Handle, x, y) + || !Sdl.SetWindowSize(Handle, (int)value.Size.X, (int)value.Size.Y) + ) + { + Sdl.ThrowError(); + } + + OnWindowCoordinatesChanged(value); + return; + void CheckForDontCare(ref int axis, ref uint display) + { + if (axis != -1) + { + return; + } + + if (display == 0) + { + display = Sdl.GetDisplayForWindow(Handle); + } + + axis = (int)(Sdl.WindowposUndefinedMask | display); + } + } + } + + public event Action? CoordinatesChanged; + + public bool IsCloseRequested + { + get; + set + { + var prev = field; + field = value; + if (!prev && value) + { + DebugPrint("Raising CloseRequested..."); + CloseRequested?.Invoke(new WindowToggleEvent(surface, true)); + } + } + } + + public event Action? CloseRequested; + + private bool _isVisible = true; + public bool IsVisible + { + get + { + if (!IsSurfaceInitialized) + { + return _isVisible; + } + + return _isVisible = (Sdl.GetWindowFlags(Handle) & Sdl.WindowHidden) == 0; + } + set + { + if (!IsSurfaceInitialized) + { + OnVisibilityChanged(value); + return; + } + + if ((value && !Sdl.ShowWindow(Handle)) || (!value && !Sdl.HideWindow(Handle))) + { + Sdl.ThrowError(); + } + OnVisibilityChanged(value); + } + } + + public event Action? VisibilityChanged; + + public bool IsFocused + { + get => !IsSurfaceInitialized || (Sdl.GetWindowFlags(Handle) & Sdl.WindowInputFocus) != 0; + set + { + if (!IsSurfaceInitialized || !value) + { + return; + } + + if (!Sdl.RaiseWindow(Handle)) + { + Sdl.ThrowError(); + } + } + } + + public event Action? FocusChanged; + + public string Title + { + get + { + if (!IsSurfaceInitialized) + { + return field; + } + + var title = Sdl.GetWindowTitle(Handle); + if (title == nullptr) + { + Sdl.ThrowError(); + } + + return field = title.ReadToString(); + } + set + { + if (!IsSurfaceInitialized) + { + field = value; + return; + } + + if (!Sdl.SetWindowTitle(Handle, value)) + { + Sdl.ThrowError(); + } + + field = value; + } + } = Assembly.GetEntryAssembly()?.GetName().Name ?? "Silk.NET Application"; + + private WindowState _state; + + public WindowState State + { + get + { + if (!IsSurfaceInitialized) + { + // The windows vs exclusive fullscreen doesn't need to be up-to-date in _state as they're encoded in the + // window create flags the same. + return _state = _state + is WindowState.ExclusiveFullscreen + or WindowState.WindowedFullscreen + ? VideoMode == default + ? WindowState.WindowedFullscreen + : WindowState.ExclusiveFullscreen + : _state; + } + var flags = Sdl.GetWindowFlags(Handle); + return _state = + (flags & Sdl.WindowFullscreen) != 0 + ? Sdl.GetWindowFullscreenMode(Handle) == nullptr + ? WindowState.WindowedFullscreen + : WindowState.ExclusiveFullscreen + : (flags & Sdl.WindowMaximized) != 0 + ? WindowState.Maximized + : (flags & Sdl.WindowMinimized) != 0 + ? WindowState.Minimized + : WindowState.Normal; + } + set => SetState(State, value); + } + + private void SetState( + WindowState current, + WindowState value, + (VideoMode Silk, Ptr Sdl)? exclusiveMode = null, + SdlDisplay? display = null + ) + { + var goingFullscreen = + value is WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen; + var wasFullscreen = + current is WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen; + if (current == value && exclusiveMode is null) + { + return; + } + + // Note that if we are changing state, we need to enact the appropriate changes to the video mode. + // If `value` is not exclusive fullscreen but we have a video mode that indicates that we're in exclusive + // fullscreen right now, then we'll change our non-default video mode to the default one. If `value` is + // exclusive fullscreen, then we change our video mode to the first available video mode. Note that because + // we've checked above whether we're actually enacting a state change, this is always valid so we don't need + // to care about the previous value of _videoMode. + display ??= (SdlDisplay)Current; + var newVideoMode = + exclusiveMode?.Silk + ?? (value == WindowState.ExclusiveFullscreen ? display.KnownVideoModes![1] : default); + if (!IsSurfaceInitialized) + { + Return(); + return; + } + + if ( + (wasFullscreen != goingFullscreen && !Sdl.SetWindowFullscreen(Handle, goingFullscreen)) + || ( + goingFullscreen + && !Sdl.SetWindowFullscreenMode( + Handle, + value == WindowState.ExclusiveFullscreen + ? exclusiveMode?.Sdl ?? display.DisplayModes[0] + : (Ref)nullptr + ) + ) + ) + { + Sdl.ThrowError(); + } + + Return(); + return; + void Return() + { + _state = value; + var oldVideoMode = _videoMode; + _videoMode = newVideoMode; + if (oldVideoMode != newVideoMode) + { + DebugPrint("Raising VideoModeChanged due to a programmatic change..."); + VideoModeChanged?.Invoke(new VideoModeChangeEvent(surface, newVideoMode)); + } + + if (current != value) + { + DebugPrint("Raising StateChanged due to a programmatic change..."); + StateChanged?.Invoke(new WindowStateEvent(surface, current, value)); + } + + if (wasFullscreen != goingFullscreen) + { + DebugPrint("Raising AvailableVideoModesChanged due to a window state change..."); + AvailableVideoModesChanged?.Invoke( + new DisplayVideoModeAvailabilityChangeEvent(surface, display) + ); + } + } + } + + public event Action? StateChanged; + + public WindowBorder Border + { + get + { + if (!IsSurfaceInitialized) + { + return field; + } + + var flags = Sdl.GetWindowFlags(Handle); + if ((flags & Sdl.WindowResizable) != 0) + { + return field = WindowBorder.Resizable; + } + + if ((flags & Sdl.WindowBorderless) != 0) + { + return field = WindowBorder.Hidden; + } + + return field = WindowBorder.Fixed; + } + set + { + if (!IsSurfaceInitialized) + { + field = value; + return; + } + + if ( + !Sdl.SetWindowBordered(Handle, value != WindowBorder.Hidden) + || !Sdl.SetWindowResizable(Handle, value == WindowBorder.Resizable) + ) + { + Sdl.ThrowError(); + } + + field = value; + OnWindowCoordinatesChanged(); // <-- Bounds includes the border + } + } + + public bool IsTopMost + { + get + { + if (!IsSurfaceInitialized) + { + return field; + } + + return field = (Sdl.GetWindowFlags(Handle) & Sdl.WindowAlwaysOnTop) != 0; + } + set + { + if (!IsSurfaceInitialized) + { + field = value; + return; + } + + if (!Sdl.SetWindowAlwaysOnTop(Handle, value)) + { + Sdl.ThrowError(); + } + + field = value; + } + } + + public event Action? FileDrop; + + private void InitializeWindow(uint props) + { + var clientArea = ClientArea; + var display = 0u; + var posX = (int)clientArea.Size.X; + var posY = (int)clientArea.Size.Y; + + // If the user has specified "don't care", we use the display configured in the display component to determine + // the position. The Display component is aware of this, and allows the user to select the display without + // changing the position if IsDisplayDeterminedByPosition is false (if it's true, then ClientArea is changed to + // go on the correct display anyway). In all other cases, the display is determined by the ClientArea. + posX = + CanPositionDetermineDisplay && posX != -1 + ? posX + : (int)(Sdl.WindowposUndefinedMask | GetDisplayId(ref display)); + posY = + CanPositionDetermineDisplay && posY != -1 + ? posY + : (int)(Sdl.WindowposUndefinedMask | GetDisplayId(ref display)); + + if ( + !Sdl.SetStringProperty(props, Sdl.PropWindowCreateTitleString, Title) + || !Sdl.SetNumberProperty( + props, + Sdl.PropWindowCreateWidthNumber, + (long)ClientArea.Size.X + ) + || !Sdl.SetNumberProperty( + props, + Sdl.PropWindowCreateHeightNumber, + (long)ClientArea.Size.Y + ) + || !Sdl.SetNumberProperty(props, Sdl.PropWindowCreateXNumber, posX) + || !Sdl.SetNumberProperty(props, Sdl.PropWindowCreateYNumber, posY) + ) + { + Sdl.ThrowError(); + } + + if (!IsWindowEnabled) + { + AddWindowCreateFlags(props, Sdl.WindowResizable | Sdl.WindowFullscreen); + return; + } + + AddWindowCreateFlags( + props, + Border switch + { + WindowBorder.Resizable => Sdl.WindowResizable, + WindowBorder.Fixed => 0ul, + WindowBorder.Hidden => Sdl.WindowBorderless, + _ => throw new ArgumentOutOfRangeException(), + } + | State switch + { + WindowState.Normal => 0ul, + WindowState.Minimized => Sdl.WindowMinimized, + WindowState.Maximized => Sdl.WindowMaximized, + WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen => + Sdl.WindowFullscreen, + _ => throw new ArgumentOutOfRangeException(), + } + | (IsVisible ? 0 : Sdl.WindowHidden) + | (IsTopMost ? Sdl.WindowAlwaysOnTop : 0) + ); + + return; + + // Helper method so this doesn't ruin my ternaries :) + // This also intentionally does not call Current so we don't unnecessarily realise SdlDisplay objects. + uint GetDisplayId(ref uint cache) + { + if (cache != 0) + { + return cache; + } + + return cache = _display?.Id ?? Sdl.GetPrimaryDisplay(); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public unsafe bool TrySetIcon(WindowIconVariants icon) + { + if (!IsSurfaceInitialized) + { + DebugPrint("attempted to set icons before window initialisation"); + return false; + } + + if (icon.Count < 1) + { + return Sdl.SetWindowIcon(Handle, nullptr); + } + + // SAFETY: Defensive checks to ensure we don't stackalloc unsafe amounts. + ArgumentOutOfRangeException.ThrowIfGreaterThan(icon.Count, 15); + ArgumentOutOfRangeException.ThrowIfLessThan(icon.Count, 0); + var surfaces = stackalloc Silk.NET.SDL.Surface*[icon.Count]; + + // Use a recursive function to set the icon, as we need to pin each individual icon. + return SetWindowIcon(Handle, surfaces, ref icon, 0, icon.Count - 1); + + // From SDL docs: No copy is made of the pixel data. Pixel data is not managed automatically; you must free the + // surface before you free the pixel data. (SDL_CreateSurfaceFrom) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static bool SetWindowIcon( + WindowHandle handle, + Silk.NET.SDL.Surface** surfaces, + ref WindowIconVariants variants, + int current, + int remaining + ) + { + ref var icon = ref variants[current]; + fixed (byte* data = icon.Data) + { + // Load this icon variant. + var surface = Sdl.CreateSurfaceFrom( + icon.Width, + icon.Height, + PixelFormat.Rgba32, + data, + 0 + ); + if (surface == nullptr) + { + return false; + } + + // Set this icon variant as a... variant... of the first variant we encountered. We'll pass that variant + // down to SDL_SetWindowIcon later. + if (current != 0 && Sdl.AddSurfaceAlternateImage(surfaces[0], surface) == 0) + { + Sdl.DestroySurface(surface); + return false; + } + + surfaces[current] = surface; + + // Copy of the data is made here, so we're safe to exit our `fixed` blocks now. + bool ret; + if (remaining == 0) + { + ret = Sdl.SetWindowIcon(handle, surfaces[0]) == 1; + } + else + { + // Load the next icon variant. + ret = SetWindowIcon(handle, surfaces, ref variants, current + 1, remaining - 1); + } + + Sdl.DestroySurface(surface); + return ret; + } + } + } + + public void OnVisibilityChanged(bool isVisible) + { + var wasVisible = _isVisible; + _isVisible = isVisible; + if (wasVisible != isVisible) + { + DebugPrint("Raising VisibilityChanged..."); + VisibilityChanged?.Invoke(new WindowToggleEvent(surface, isVisible)); + } + } + + public void OnWindowCoordinatesChanged(Rectangle? requestedClientArea = null) + { + var oldBounds = _bounds; + var oldClientArea = _clientArea; + Rectangle newBounds; + Rectangle newClientArea; + if (requestedClientArea is { } ca) + { + newBounds = GetBounds(ca); + newClientArea = ca; + } + else + { + newBounds = Bounds; + newClientArea = _clientArea; // <-- not a typo! Bounds getter calls ClientArea getter and updates this + } + + _clientArea = newClientArea; + _bounds = newBounds; + if (oldBounds == newBounds && oldClientArea == newClientArea) + { + return; + } + + DebugPrint("Raising CoordinatesChanged..."); + CoordinatesChanged?.Invoke( + new WindowCoordinatesEvent(surface, oldBounds, oldClientArea, newBounds, newClientArea) + ); + } + + private void PostInitializeWindow() => OnWindowCoordinatesChanged(); + + public void OnWindowStateChanged(WindowState? newState = null) + { + var oldState = _state; + _state = newState ?? State; + if (oldState == _state) + { + return; + } + + DebugPrint("Raising StateChanged due to a detected change..."); + StateChanged?.Invoke(new WindowStateEvent(surface, oldState, _state)); + if ( + oldState is WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen + || _state is WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen + ) + { + OnVideoModeChanged(); // just in case of exclusive vs windowed differences + } + } + + public void OnWindowFocusChanged(bool value) + { + DebugPrint("Raising FocusChanged..."); + FocusChanged?.Invoke(new WindowToggleEvent(surface, value)); + } + + public void OnFileDrop(IReadOnlyList droppedFiles) + { + DebugPrint("Raising FileDrop..."); + FileDrop?.Invoke(new WindowFileEvent(surface, droppedFiles)); + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs new file mode 100644 index 0000000000..59ba9bc46a --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs @@ -0,0 +1,255 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +#pragma warning disable CS9113 // Parameter is unread. +internal partial class SdlSurfaceComponents(SdlSurface surface) +#pragma warning restore CS9113 // Parameter is unread. +{ + public static bool IsChildrenEnabled { get; private set; } + public static bool IsDisplayEnabled => true; + public static bool IsOpenGLEnabled { get; private set; } + public static bool IsScaleEnabled => true; + public static bool IsVulkanEnabled { get; private set; } + public static bool IsWindowEnabled { get; private set; } + + /// + /// The window handle. Before creation this is either nullptr or a temporary window handle. + /// + public WindowHandle Handle { get; private set; } + + /// + /// The window ID. Only valid if is valid and is + /// true. + /// + public uint Id { get; private set; } + + public bool IsSurfaceInitialized { get; set; } + + private static uint _platformInitCount; + + private void AssertUninit() + { + if (IsSurfaceInitialized) + { + throw new InvalidOperationException( + "This property can only be set during surface initialization (i.e. " + + "within the ISurfaceApplication.Initialize() method)." + ); + } + } + + private static void AddWindowCreateFlags(uint props, ulong flags) + { + var currentFlags = unchecked( + (ulong)Sdl.GetNumberProperty(props, Sdl.PropWindowCreateFlagsNumber, 0) + ); + currentFlags |= flags; + if ( + !Sdl.SetNumberProperty( + props, + Sdl.PropWindowCreateFlagsNumber, + unchecked((long)currentFlags) + ) + ) + { + Sdl.ThrowError(); + } + } + + /// + /// Initializes the platform and returns the temporary window handle used in the process if applicable. + /// + /// + /// The window handle. May be nullptr, in which case the platform was already initialised. + /// + public static WindowHandle InitializePlatform() + { + DebugPrint($"reached, ref count before {_platformInitCount}"); + if (Interlocked.Increment(ref _platformInitCount) > 1) + { + return nullptr; + } + + if (!Sdl.InitSubSystem(Sdl.InitVideo)) + { + Sdl.ThrowError(); + return nullptr; + } + + IsOpenGLEnabled = Sdl.GLLoadLibrary(nullptr); + DebugPrintWithError(IsOpenGLEnabled ? "OpenGL support enabled" : "OpenGL support disabled"); + + IsVulkanEnabled = Sdl.VulkanLoadLibrary(nullptr); + DebugPrintWithError(IsVulkanEnabled ? "Vulkan support enabled" : "Vulkan support disabled"); + Sdl.ClearError(); + + var tempWindow = Sdl.CreateWindow("Dummy Window", 1, 1, Sdl.WindowHidden); + if (tempWindow == nullptr) + { + // Should be able to at least create a window. + Sdl.ThrowError(); + return nullptr; + } + + var tempChildWindow = Sdl.CreateWindow("Dummy Window 2", 1, 1, Sdl.WindowHidden); + if (tempChildWindow != nullptr) + { + IsChildrenEnabled = true; + Sdl.DestroyWindow(tempChildWindow); + } + + DebugPrintWithError(IsChildrenEnabled ? "Children supported" : "Children unsupported"); + Sdl.ClearError(); + + IsWindowEnabled = Sdl.SetWindowPosition(tempWindow, 1, 1); + DebugPrintWithError($"Window decoration {(IsWindowEnabled ? "supported" : "unsupported")}"); + Sdl.ClearError(); + return tempWindow; + } + + private WindowHandle GetDummyWindow(ulong flags = 0, ulong nFlags = 0) + { + flags |= Sdl.WindowHidden; + ulong originalFlags = 0; + if ( + Handle != nullptr + && flags == (flags & (flags |= (originalFlags = Sdl.GetWindowFlags(Handle)))) + ) + { + return Handle; + } + + flags &= ~nFlags; + Sdl.DestroyWindow(Handle); // so we don't get errors pertaining to multi-window on single-window platforms + var ret = Sdl.CreateWindow("Dummy Window", 1, 1, flags); + if (ret == nullptr) + { + if (originalFlags != 0) + { + // Recreate the old dummy window. + Handle = Sdl.CreateWindow("Dummy Window", 1, 1, originalFlags); + } + } + else + { + Handle = ret; + } + + return ret; + } + + public void PreInitializeSurface() + { + DebugPrint(); + Handle = InitializePlatform(); + } + + public void InitializeSurface() + { + var createProps = Sdl.CreateProperties(); + try + { + if (IsChildrenEnabled) + { + InitializeChildren(createProps); + } + + if (IsOpenGLEnabled) + { + InitializeOpenGL(createProps); + } + + if (IsScaleEnabled) + { + InitializeScale(createProps); + } + + if (IsVulkanEnabled) + { + InitializeVulkan(createProps); + } + + if (IsWindowEnabled) + { + InitializeWindow(createProps); + } + + if (Handle != nullptr) + { + Sdl.DestroyWindow(Handle); + } + + DebugPrintAllProps(createProps); + Handle = Sdl.CreateWindowWithProperties(createProps); + } + finally + { + Sdl.DestroyProperties(createProps); + } + + if (Handle == nullptr) + { + Sdl.ThrowError(); + } + + Id = Sdl.GetWindowID(Handle); + SdlEventProcessor.AddSurface(Id, surface); + DebugPrintAllProps(Sdl.GetWindowProperties(Handle)); + IsSurfaceInitialized = true; + if (IsOpenGLEnabled) + { + PostInitializeOpenGL(); + } + + if (IsScaleEnabled) + { + PostInitializeScale(); + } + + if (IsWindowEnabled) + { + PostInitializeWindow(); + } + + if (IsDisplayEnabled) + { + PostInitializeDisplay(); + } + } + + public static void TerminatePlatform() + { + DebugPrint($"reached, ref count is {_platformInitCount}"); + if (Interlocked.Decrement(ref _platformInitCount) != 0) + { + return; + } + + Sdl.QuitSubSystem(Sdl.InitVideo); + if (IsOpenGLEnabled) + { + Sdl.GLUnloadLibrary(); + } + + if (IsVulkanEnabled) + { + Sdl.VulkanUnloadLibrary(); + } + } + + public void Dispose() + { + if (Handle != nullptr) + { + SdlEventProcessor.RemoveSurface(Id); + Sdl.DestroyWindow(Handle); + } + + TerminatePlatform(); + } +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs new file mode 100644 index 0000000000..60a30150e6 --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs @@ -0,0 +1,147 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.InteropServices; +using Silk.NET.SDL; + +namespace Silk.NET.Windowing.SDL3; + +internal unsafe class SdlSurfaceLifecycle(SdlSurface surface) : IDetachedSurfaceLifecycle +{ + /// + /// The function used to initialize the attached to the surface. + /// This is not used for detached surfaces. + /// + private static delegate* _attachedLifecycleInit; + + /// + /// The first attached surface. + /// + private static SdlSurface? _attachedLifecycleRootSurface; + + /// + /// The for + /// - + /// used on attached surfaces. This executes the tick. + /// + public static AppIterateFunc AppIterate => (delegate* unmanaged)&AttachedTick; + public static AppEventFunc AppEvent => + (delegate* unmanaged)&AttachedEvent; + public static AppQuitFunc AppQuit => + (delegate* unmanaged)&AttachedDispose; + + public Surface Surface => surface; + + public static AppInitFunc AppInit() + where T : ISurfaceApplication + { + // Work around unmanaged functions not being allowed to be generic. + _attachedLifecycleInit = &CoreInit; + return (delegate* unmanaged)&AttachedLifecycleInit; + } + + [UnmanagedCallersOnly] + private static AppResult AttachedLifecycleInit(void** appstate, int argc, sbyte** argv) + { + DebugPrint(); + _attachedLifecycleRootSurface = _attachedLifecycleInit(); + _attachedLifecycleInit = null; + return AppResult.Continue; + } + + public static SdlSurface CoreInit() + where T : ISurfaceApplication + { + if (T.WindowClass is { } wc && !Sdl.SetHint(Sdl.HintAppId, wc)) // haha toilet + { + Sdl.ThrowError(); + } + + return CoreInit(null); + } + + public static SdlSurface CoreInit(SdlSurface? parent) + where T : ISurfaceApplication + { + DebugPrint(); + var surface = new SdlSurface { Parent = parent }; + surface.PreInitialize(); + T.Initialize(surface); + surface.Initialize(); + return surface; + } + + [UnmanagedCallersOnly] + private static AppResult AttachedTick(void* appstate) => + // TODO TickOptions.IsEventDriven: https://github.com/libsdl-org/SDL/issues/11387 + _attachedLifecycleRootSurface is not null + && CoreTick(_attachedLifecycleRootSurface) + ? _attachedLifecycleRootSurface.IsTerminating + ? AppResult.Success + : AppResult.Continue + : AppResult.Failure; + + private static bool CoreTick(SdlSurface surface) + { + surface.OnTick(); + if (surface.Window?.IsCloseRequested ?? false) + { + DebugPrint("surface closure was requested by the end of a tick, terminating surface."); + surface.Terminate(); + } + + return true; + } + + public void Tick() + { + Event @event = default; + if ( + Surface.TickOptions.IsEventDriven + ? Sdl.WaitEvent(@event.AsRef()) + : Sdl.PollEvent(@event.AsRef()) + ) + { + SdlEventProcessor.DeliverEvent(ref @event); + } + + CoreTick(surface); + } + + [UnmanagedCallersOnly] + private static AppResult AttachedEvent(void* appstate, Event* @event) + { + if (_attachedLifecycleRootSurface is not null) + { + CoreEvent(_attachedLifecycleRootSurface, ref *@event); + } + else + { + DebugPrint($"got {(EventType)@event->Type} but no surface attached."); + } + + return AppResult.Continue; + } + + private static void CoreEvent(SdlSurface surface, ref Event @event) + { + DebugPrint($"got {(EventType)@event.Type}, root surface is {surface}."); + SdlEventProcessor.DeliverEvent(ref @event); + } + + [UnmanagedCallersOnly] + private static void AttachedDispose(void* appstate, AppResult lastResult) + { + DebugPrint(); + if (_attachedLifecycleRootSurface is not null) + { + CoreDispose(_attachedLifecycleRootSurface); + } + + _attachedLifecycleRootSurface = null; + } + + private static void CoreDispose(SdlSurface surface) => surface.Dispose(); + + public void Dispose() => CoreDispose(surface); +} diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SilkActivity.cs b/sources/Windowing/Windowing/Implementations/SDL3/SilkActivity.cs new file mode 100644 index 0000000000..3634bbf2ec --- /dev/null +++ b/sources/Windowing/Windowing/Implementations/SDL3/SilkActivity.cs @@ -0,0 +1,14 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if ANDROID +using Org.Libsdl.App; + +namespace Silk.NET.Windowing.SDL3; + +public abstract class SilkActivity : SDLActivity + where T : ISurfaceApplication +{ + protected override void Main() => ISurfaceApplication.Run(); +} +#endif diff --git a/sources/Windowing/Windowing/OpenGLContextFlags.cs b/sources/Windowing/Windowing/OpenGLContextFlags.cs new file mode 100644 index 0000000000..be7abcfdd1 --- /dev/null +++ b/sources/Windowing/Windowing/OpenGLContextFlags.cs @@ -0,0 +1,25 @@ +namespace Silk.NET.Windowing; + +/// +/// Represents flags related to the OpenGL context. +/// +[Flags] +public enum OpenGLContextFlags +{ + /// + /// No flags enabled. + /// + Default = 0, + + /// + /// Enables debug context; debug contexts provide more debugging info, but can run slower. + /// + Debug = 1 << 0, + + /// + /// Enables forward compatibility; this context won't support anything marked as deprecated in the current + /// version. + /// + /// On OpenGL contexts older than 3.0, this flag does nothing. + ForwardCompatible = 1 << 1, +} diff --git a/sources/Windowing/Windowing/OpenGLContextProfile.cs b/sources/Windowing/Windowing/OpenGLContextProfile.cs new file mode 100644 index 0000000000..606a632c65 --- /dev/null +++ b/sources/Windowing/Windowing/OpenGLContextProfile.cs @@ -0,0 +1,34 @@ +namespace Silk.NET.Windowing; + +/// +/// Represents the context profile OpenGL should use. +/// +public enum OpenGLContextProfile +{ + /// + /// An OpenGL context will not be created for this surface. + /// + None = 0, + + /// + /// Use the platform default context profile e.g. on mobile platforms, + /// otherwise. + /// + Default, + + /// + /// Uses a core OpenGL context, which removes some deprecated functionality. + /// + Core, + + /// + /// Uses a compatibility OpenGL context, allowing for some deprecated functionality. This should only ever be + /// used for maintaining legacy code; no newly-written software should use this. + /// + Compatibility, + + /// + /// Uses an OpenGLES 2+ profile. + /// + ES2, +} diff --git a/sources/Windowing/Windowing/ScaleChangedEvent.cs b/sources/Windowing/Windowing/ScaleChangedEvent.cs new file mode 100644 index 0000000000..ff5e184aaf --- /dev/null +++ b/sources/Windowing/Windowing/ScaleChangedEvent.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. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a change in a surface's scale. +/// +/// The surface to which the change in scale occurred. +/// The previous value for . +/// The new value for . +/// The previous value for . +/// The new value for . +/// The previous value for . +/// The new value for . +public readonly record struct ScaleChangedEvent( + Surface Surface, + float OldContent, + float NewContent, + float OldDraw, + float NewDraw, + float OldPixelDensity, + float NewPixelDensity +); diff --git a/sources/Windowing/Windowing/Silk.NET.Windowing.csproj b/sources/Windowing/Windowing/Silk.NET.Windowing.csproj new file mode 100644 index 0000000000..a8dae4fa38 --- /dev/null +++ b/sources/Windowing/Windowing/Silk.NET.Windowing.csproj @@ -0,0 +1,18 @@ + + + + net8.0;net9.0 + $(TargetFrameworks);net8.0-android;net9.0-android + $(TargetFrameworks);net8.0-ios;net9.0-ios + enable + enable + + + + + + + + + + diff --git a/sources/Windowing/Windowing/Silk.NET.Windowing.csproj.DotSettings b/sources/Windowing/Windowing/Silk.NET.Windowing.csproj.DotSettings new file mode 100644 index 0000000000..10361e88b3 --- /dev/null +++ b/sources/Windowing/Windowing/Silk.NET.Windowing.csproj.DotSettings @@ -0,0 +1,2 @@ + + True \ No newline at end of file diff --git a/sources/Windowing/Windowing/Surface.cs b/sources/Windowing/Windowing/Surface.cs new file mode 100644 index 0000000000..e2605e428d --- /dev/null +++ b/sources/Windowing/Windowing/Surface.cs @@ -0,0 +1,319 @@ +namespace Silk.NET.Windowing; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Numerics; + +/// +/// Represents a surface within which a user application can run. This class contains a modular, cross-platform +/// interface with which the platform's multimedia capabilities can be configured and the execution of the application +/// within the surface controlled. +/// +public abstract class Surface : IGLContextSource, INativeWindow +{ + /// + /// Gets the OpenGL configuration of the surface, if supported. + /// + public virtual ISurfaceOpenGL? OpenGL => null; + + /// + /// Gets the configuration for the window in which the surface is being drawn. + /// + public virtual ISurfaceWindow? Window => null; + + /// + /// Gets the display configuration for the surface, if supported. + /// + public virtual ISurfaceDisplay? Display => null; + + /// + /// Gets the Vulkan component of this surface. + /// + public virtual ISurfaceVulkan? Vulkan => null; + + /// + /// Gets the "child surface" functionality if available. + /// + public virtual ISurfaceChildren? Children => null; + + /// + /// Gets the content scale configuration within the surface. + /// + public virtual ISurfaceScale? Scale => null; + + IGLContext? IGLContextSource.GLContext => OpenGL; + + /// + /// Gets the size in pixels of the area drawable within the surface. + /// + public abstract Vector2 DrawableSize { get; } + + /// + /// Gets a value indicating whether the surface is terminating irrevocably. + /// + /// + public abstract bool IsTerminating { get; } + + /// + /// An event raised as frequently as possible (or in line with ). + /// + public event Action? Tick; + + /// + /// An event raised in accordance with with the intention of providing the application + /// an opportunity to redraw its graphics within the surface. + /// + public event Action? Render; + + /// + /// An event raised in accordance with with the intention of providing the application + /// an opportunity to redraw its graphics within the surface. + /// + public event Action? Update; + + /// + /// Raised when changes. + /// + public abstract event Action? DrawableSizeChanged; + + /// + /// An event executed when the surface is first loaded. + /// + public abstract event Action? Created; + + /// + /// An event executed when the surface and the application thereof are about to terminate irrevocably. + /// + public abstract event Action? Terminating; + + /// + /// An event executed when the surface and the application thereof are pausing on request of the operating system. + /// + public abstract event Action? Pausing; + + /// + /// An event executed when the surface and the application thereof are resuming on request of the operating system. + /// + public abstract event Action? Resuming; + + /// + /// An event executed when the operating system indicates the amount of memory that can be allocated for the + /// application running the surface is low. + /// + public abstract event Action? LowMemory; + + /// + /// Gets or sets additional configuration/constraints for the event. + /// + public abstract SurfaceTickOptions TickOptions { get; set; } + + /// + /// Gets or sets additional configuration/constraints for the event. + /// + /// Failure to call into the base property will result in incorrect behaviour. + public virtual SurfaceTimingOptions RenderOptions + { + get => new(GetDelta(_renderFrequency)); + set => _renderFrequency = GetFrequencyValue(value.TargetDelta); + } + + /// + /// Gets or sets additional configuration/constraints for the event. + /// + /// Failure to call into the base property will result in incorrect behaviour. + public virtual SurfaceTimingOptions UpdateOptions + { + get => new(GetDelta(_updateFrequency)); + set => _updateFrequency = GetFrequencyValue(value.TargetDelta); + } + + // It is expected that the timing logic be common code i.e. all of these APIs shall be implemented in `Surface` and + // not a derived type. `FramesPerSecond` and `UpdatesPerSecond` shall to forward to `RenderOptions.TargetDelta` and + // `UpdateOptions.TargetDelta` respectively with the value of `1 / value`. `SurfaceTimingOptions` has been + // introduced for future proofing in the event that we want to add more options such as executing one of the events + // on a different thread (e.g. as in Silk.NET 1.X when the `UseSingleThreadedWindow` option was set to `false`). + // These settings shall default to run as fast as possible. A `TargetDelta` value close to zero or a negative number + // is interpreted to mean run as fast as possible. This shall be represented by `FramesPerSecond`/`UpdatesPerSecond` + // as a negative number. A `TargetDelta` value close to `double.MaxValue` shall be interpreted to mean "never + // execute". This shall be represented by `FramesPerSecond`/`UpdatesPerSecond` as zero. The `OnRender` and + // `OnUpdate` methods shall raise the `Render` and `Update` events respectively, which the implementation has the + // opportunity to override. + private static int GetPerSecondValue(ulong frequency) => + frequency switch + { + 0 => -1, + ulong.MaxValue => 0, + _ => (int)(frequency / (ulong)Stopwatch.Frequency), + }; + + private static ulong GetFrequencyValue(int perSecond) => + perSecond switch + { + < 0 => 0, + 0 => ulong.MaxValue, + _ => (ulong)(Stopwatch.Frequency / perSecond), + }; + + private static double GetDelta(ulong frequency) => + frequency switch + { + ulong.MaxValue => double.MaxValue, + 0 => 0, + _ => (double)frequency / Stopwatch.Frequency, + }; + + private static ulong GetFrequencyValue(double targetDelta) + { + if (targetDelta <= 0) + { + return 0; + } + + if (Math.Abs(targetDelta - double.MaxValue) < double.Epsilon) + { + return ulong.MaxValue; + } + + return (ulong)(targetDelta * Stopwatch.Frequency); + } + + /// + /// Gets or sets a value representing . + /// as a number of executions per second. + /// + public int FramesPerSecond + { + get => GetPerSecondValue(_renderFrequency); + set => _renderFrequency = GetFrequencyValue(value); + } + + /// + /// Gets or sets a value representing . + /// as a number of executions per second. + /// + public int UpdatesPerSecond + { + get => GetPerSecondValue(_updateFrequency); + set => _updateFrequency = GetFrequencyValue(value); + } + + /// + /// Provides a strong hint to the underlying platform that a tick should execute. This is mainly useful for + /// . where execution of this method + /// constitutes an event. + /// + public abstract void Continue(); + + /// + /// Irrevocably terminates this surface and the application running within it, resulting in the immediate ceasing of + /// event execution and all derived events thereof. The surface cannot recover from this state, + /// requiring the relaunch of the if available on the platform. + /// + public abstract void Terminate(); + + private ulong _lastTick; + private ulong _lastRender; + private ulong _renderFrequency; + private ulong _lastUpdate; + private ulong _updateFrequency; + + private static bool TimeCheck(ref ulong lastTimestamp, ulong frequency, out ulong diff) + { + diff = 0; + if (frequency == ulong.MaxValue) + { + return false; + } + + var now = (ulong)Stopwatch.GetTimestamp(); + if (now < lastTimestamp + frequency) + { + return false; + } + + diff = now - lastTimestamp; + lastTimestamp = now; + return true; + } + + /// + /// Executes the event. This will also call and . + /// + protected internal virtual void OnTick() + { + TimeCheck(ref _lastTick, 0, out var diff); + Tick?.Invoke(new SurfaceTimingEvent(this, diff / (double)Stopwatch.Frequency)); + OnUpdate(); + OnRender(); + } + + /// + /// Executes the event if the constraints defined in are met. + /// + protected internal virtual void OnRender() + { + if ( + !TimeCheck(ref _lastRender, _renderFrequency, out var diff) + && OpenGL is not { IsEnabled: true, VSync: true } + ) + { + return; + } + + Render?.Invoke(new SurfaceTimingEvent(this, diff / (double)Stopwatch.Frequency)); + if (OpenGL is { IsEnabled: true, IsCurrent: true, ShouldSwapAutomatically: true }) + { + OpenGL.SwapBuffers(); + } + } + + /// + /// Executes the event if the constraints defined in are met. + /// + protected internal virtual void OnUpdate() + { + if (!TimeCheck(ref _lastUpdate, _updateFrequency, out var diff)) + { + return; + } + + Update?.Invoke(new SurfaceTimingEvent(this, diff / (double)Stopwatch.Frequency)); + } + + /// + /// Centers this window to the given monitor or, if null, the current monitor the window's on. + /// + /// The specific display to center the window to, if any. + public void Center(IDisplay? display = null) => throw new NotImplementedException(); + + /// + /// Converts a point that is defined in the same coordinate space as to instead be + /// defined relative to . Requires both and + /// components to be supported, if not shall be returned as is. + /// + /// The point to transform. + /// The transformed point. + public Vector2 ScreenToClient(Vector2 point) => throw new NotImplementedException(); + + /// + /// Converts a point that is defined relative to to instead be defined in the + /// same coordinate space as . Requires both and + /// components to be supported, if not shall be returned as is. + /// + /// The point to transform. + /// The transformed point. + public Vector2 ClientToScreen(Vector2 point) => throw new NotImplementedException(); + + /// + /// Converts a point that is defined relative to by multiplying it with the + /// division of by 's size. + /// + /// The point to transform. + /// The transformed point. + public Vector2 ClientToDrawable(Vector2 point) => throw new NotImplementedException(); + + /// + public abstract bool TryGetPlatformInfo( + [NotNullWhen(true)] out TPlatformInfo? info + ); +} diff --git a/sources/Windowing/Windowing/SurfaceLifecycleEvent.cs b/sources/Windowing/Windowing/SurfaceLifecycleEvent.cs new file mode 100644 index 0000000000..86c71f39d5 --- /dev/null +++ b/sources/Windowing/Windowing/SurfaceLifecycleEvent.cs @@ -0,0 +1,7 @@ +namespace Silk.NET.Windowing; + +/// +/// Contains parameters for events executed in response to an application lifecycle notification being issued to a +/// surface. +/// +public readonly record struct SurfaceLifecycleEvent(Surface Surface); diff --git a/sources/Windowing/Windowing/SurfaceResizeEvent.cs b/sources/Windowing/Windowing/SurfaceResizeEvent.cs new file mode 100644 index 0000000000..4af15d185b --- /dev/null +++ b/sources/Windowing/Windowing/SurfaceResizeEvent.cs @@ -0,0 +1,11 @@ +namespace Silk.NET.Windowing; + +using System.Numerics; + +/// +/// Contains properties pertaining to a resize event. +/// +/// The surface raising the resize event. +/// The previous size value. +/// The new size value. +public readonly record struct SurfaceResizeEvent(Surface Surface, Vector2 OldSize, Vector2 NewSize); diff --git a/sources/Windowing/Windowing/SurfaceTickOptions.cs b/sources/Windowing/Windowing/SurfaceTickOptions.cs new file mode 100644 index 0000000000..a95ceafe41 --- /dev/null +++ b/sources/Windowing/Windowing/SurfaceTickOptions.cs @@ -0,0 +1,11 @@ +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to the regular execution of the event. +/// +/// +/// Whether should only execute in response to an event (of any kind) and/or +/// if true; if false the event shall be raised as frequently as the +/// implementation/platform can handle. +/// +public readonly record struct SurfaceTickOptions(bool IsEventDriven); diff --git a/sources/Windowing/Windowing/SurfaceTimingEvent.cs b/sources/Windowing/Windowing/SurfaceTimingEvent.cs new file mode 100644 index 0000000000..9667723cde --- /dev/null +++ b/sources/Windowing/Windowing/SurfaceTimingEvent.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains parameters for events executed at predictable intervals by a . +/// +/// The surface to which the event pertains. +/// The number of seconds that have elapsed since the last execution of this event. +public readonly record struct SurfaceTimingEvent(Surface Surface, double DeltaTime); diff --git a/sources/Windowing/Windowing/SurfaceTimingOptions.cs b/sources/Windowing/Windowing/SurfaceTimingOptions.cs new file mode 100644 index 0000000000..88ffba56b2 --- /dev/null +++ b/sources/Windowing/Windowing/SurfaceTimingOptions.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to events a surface shall raise at predictable intervals. +/// +/// +/// The target number of seconds for the surface between the start of the previous execution of the event, and the start +/// of the next execution. +/// +/// +/// Note that timed events are executed in terms of the surface's tick frequency. If +/// is set to run the event at a lower frequency than is targeted by this event, it is +/// impossible to meet the . +/// +public readonly record struct SurfaceTimingOptions(double TargetDelta); diff --git a/sources/Windowing/Windowing/VideoMode.cs b/sources/Windowing/Windowing/VideoMode.cs new file mode 100644 index 0000000000..212c529c69 --- /dev/null +++ b/sources/Windowing/Windowing/VideoMode.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. + +namespace Silk.NET.Windowing; + +using System.Numerics; + +/// +/// Represents the properties of a surface whose rendering is intrinsically linked to the composition of a specific +/// display. In most cases, this translates to "the surface is rendering in fullscreen mode". +/// +/// The index of the video mode in . +/// +/// The resolution the surface is rendering on its display at, if known. If null, it is highly likely that the +/// surface is not rendering in fullscreen mode or otherwise has its rendering intrinsically linked to the composition +/// of a specific display. +/// +/// +/// The rate (per second) at which the physical display will receive new renders from the surface, if known. If +/// null, the platform may not expose the refresh rate to surfaces or it is highly likely that the +/// surface is not rendering in fullscreen mode or otherwise has its rendering intrinsically linked to the composition +/// of a specific display. +/// +/// +/// If a default video mode is encountered, it is highly likely the surface is not rendering in fullscreen mode. +/// If an individual property is null, it is highly likely that property is not controllable programmatically. +/// +public readonly record struct VideoMode(int Index, Vector2? Resolution, float? RefreshRate); diff --git a/sources/Windowing/Windowing/VideoModeChangeEvent.cs b/sources/Windowing/Windowing/VideoModeChangeEvent.cs new file mode 100644 index 0000000000..238c284703 --- /dev/null +++ b/sources/Windowing/Windowing/VideoModeChangeEvent.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a surface changing to a different video mode. +/// +/// The surface changing to a different video mode. +/// The video mode the surface has changed to. +public readonly record struct VideoModeChangeEvent(Surface Surface, VideoMode VideoMode); diff --git a/sources/Windowing/Windowing/WindowBorder.cs b/sources/Windowing/Windowing/WindowBorder.cs new file mode 100644 index 0000000000..19c7bce548 --- /dev/null +++ b/sources/Windowing/Windowing/WindowBorder.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Represents the window border. +/// +public enum WindowBorder +{ + /// + /// The window can be resized by clicking and dragging its border. + /// + Resizable = 0, + + /// + /// The window border is visible, but cannot be resized. All window-resizings must happen solely in the code. + /// + Fixed, + + /// + /// The window border is hidden. + /// + Hidden, +} diff --git a/sources/Windowing/Windowing/WindowCoordinatesEvent.cs b/sources/Windowing/Windowing/WindowCoordinatesEvent.cs new file mode 100644 index 0000000000..067196d3ab --- /dev/null +++ b/sources/Windowing/Windowing/WindowCoordinatesEvent.cs @@ -0,0 +1,54 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +using System.Numerics; +using Silk.NET.Maths; + +/// +/// Contains properties pertaining to the window's position or size changing. +/// +/// The surface that owns the window the event pertains to. +/// The previous value of . +/// The new value of . +/// The previous value of . +/// The new value of . +public readonly record struct WindowCoordinatesEvent( + Surface Surface, + Rectangle OldBounds, + Rectangle NewBounds, + Rectangle OldClientArea, + Rectangle NewClientArea +) +{ + /// + /// The previous value of . + /// + public Vector2 OldSize => (Vector2)OldBounds.Size; + + /// + /// The new value of . + /// + public Vector2 NewSize => (Vector2)NewBounds.Size; + + /// + /// The previous value of . + /// + public Vector2 OldClientSize => (Vector2)OldClientArea.Size; + + /// + /// The new value of . + /// + public Vector2 NewClientSize => (Vector2)NewClientArea.Size; + + /// + /// The previous value of . + /// + public Vector2 OldPosition => (Vector2)OldBounds.Origin; + + /// + /// The new value of . + /// + public Vector2 NewPosition => (Vector2)NewBounds.Origin; +} diff --git a/sources/Windowing/Windowing/WindowFileEvent.cs b/sources/Windowing/Windowing/WindowFileEvent.cs new file mode 100644 index 0000000000..c7ea5ca908 --- /dev/null +++ b/sources/Windowing/Windowing/WindowFileEvent.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to one or more files being dropped onto a window. +/// +/// The surface that owns the window to which the event pertains. +/// The paths of the files dropped onto the window. +public readonly record struct WindowFileEvent(Surface Surface, IReadOnlyList Files); diff --git a/sources/Windowing/Windowing/WindowIcon.cs b/sources/Windowing/Windowing/WindowIcon.cs new file mode 100644 index 0000000000..1b3672f72e --- /dev/null +++ b/sources/Windowing/Windowing/WindowIcon.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. + +namespace Silk.NET.Windowing; + +/// +/// Represents a single window icon. +/// +public ref struct WindowIcon +{ + /// + /// The width of the window icon. + /// + public required int Width { get; init; } + + /// + /// The height of the window icon. + /// + public required int Height { get; init; } + + /// + /// The window icon's pixel data in row-major order, where 4 bytes are allocated for each pixel and 1 byte + /// representing each of the red, green, blue, and alpha channels (in that order). + /// + public required ReadOnlySpan Data { get; init; } +} diff --git a/sources/Windowing/Windowing/WindowIconVariants.cs b/sources/Windowing/Windowing/WindowIconVariants.cs new file mode 100644 index 0000000000..fa9ac0e397 --- /dev/null +++ b/sources/Windowing/Windowing/WindowIconVariants.cs @@ -0,0 +1,221 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if NET9_0_OR_GREATER +using System.Collections; +#endif + +namespace Silk.NET.Windowing; + +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; + +/// +/// One or more s representing multiple variants (e.g. for size/DPI differences) of the same +/// window icon. +/// +public ref struct WindowIconVariants +#if NET9_0_OR_GREATER + : IEnumerable +#endif +{ + /// + /// The maximum number of variants. + /// + public const int MaxVariants = 16; + + private int _count; + private WindowIcon _e0; + private WindowIcon _e1; + private WindowIcon _e2; + private WindowIcon _e3; + private WindowIcon _e4; + private WindowIcon _e5; + private WindowIcon _e6; + private WindowIcon _e7; + private WindowIcon _e8; + private WindowIcon _e9; + private WindowIcon _e10; + private WindowIcon _e11; + private WindowIcon _e12; + private WindowIcon _e13; + private WindowIcon _e14; + private WindowIcon _e15; + + /// + /// Gets or sets the window icon variant at the given index. + /// + /// The index, between 0 and . + [UnscopedRef] + public ref WindowIcon this[int index] + { + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + get + { + ArgumentOutOfRangeException.ThrowIfGreaterThan(index, _count); + return ref DangerousGetElement(index); + } + } + + /// + /// Gets a reference to the element at the given index without checking whether indicates that + /// the element at the given index is populated. + /// + /// The index, between 0 and . + /// The element. + /// + /// was not between 0 and . + /// + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + private ref WindowIcon DangerousGetElement(int index) + { + // csharpier-ignore-start + // ReSharper disable EnforceIfStatementBraces - for readability/editability + // ReSharper disable ConvertIfStatementToSwitchStatement - false positive + if (index == 0) return ref _e0; + if (index == 1) return ref _e1; + if (index == 2) return ref _e2; + if (index == 3) return ref _e3; + if (index == 4) return ref _e4; + if (index == 5) return ref _e5; + if (index == 6) return ref _e6; + if (index == 7) return ref _e7; + if (index == 8) return ref _e8; + if (index == 9) return ref _e9; + if (index == 10) return ref _e10; + if (index == 11) return ref _e11; + if (index == 12) return ref _e12; + if (index == 13) return ref _e13; + if (index == 14) return ref _e14; + if (index == 15) return ref _e15; + throw new ArgumentOutOfRangeException(nameof(index)); + // ReSharper restore ConvertIfStatementToSwitchStatement + // ReSharper restore EnforceIfStatementBraces + // csharpier-ignore-end + } + + /// + /// Creates a window icon with just one variant. + /// + public WindowIconVariants(WindowIcon icon) + { + _e0 = icon; + _count = 1; + } + + /// + /// Gets the number of variants within this window icon. + /// + public int Count => _count; + + /// + /// Adds a variant. + /// + /// The variant to add. + public void Add(WindowIcon icon) + { + if (_count == MaxVariants) + { + throw new InvalidOperationException( + "The maximum number of variants have been reached." + ); + } + + this[_count++] = icon; + } + + /// + /// Removes the variant at the given index. + /// + /// The index to remove at. All elements thereafter will be shifted left by one. + public void RemoveAt(int i) + { + ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(i, _count); + for (var j = i; j < _count - 1; j++) + { + this[j] = this[j + 1]; + } + + _count--; + } + + /// + /// Converts a into a with one variant. + /// + /// The icon. + /// The single-variant incorporating + public static implicit operator WindowIconVariants(WindowIcon icon) => new(icon); + + /// + /// Enumerates the variants contained within this . + /// + /// An enumerator. + public Enumerator GetEnumerator() => new(this); + +#if NET9_0_OR_GREATER + // Will return byte[,] elements, this is only implemented to make collection/initializer expressions to light up. + // Not implementing the generic interface to further discourage use. + // Ref structs can only implement interfaces as of C# 13/.NET 9 + IEnumerator IEnumerable.GetEnumerator() + { + // Dear god this is terrible, it's a good thing noone will ever use it. + var array = new byte[_count][,]; + for (var i = 0; i < _count; i++) + { + var icon = this[i]; + array[i] = new byte[icon.Width, icon.Height]; + for (var x = 0; x < icon.Width; x++) + { + for (var y = 0; y < icon.Height; y++) + { + array[i][x, y] = icon.Data[(y * icon.Width) + x]; + } + } + } + + return array.GetEnumerator(); + } +#endif + + /// + /// An enumerator over s contained in . This can only be + /// created using . + /// + public ref struct Enumerator + { + private WindowIconVariants _variants; + private int _current; + + internal Enumerator(WindowIconVariants variants) => _variants = variants; + + /// + /// The output from if that returned true. + /// + // --------------------------vvvvvvvvvvvvv---------- protect against default(WindowIconVariants.Enumerator) + public WindowIcon Current => _current == 0 ? default : _variants[_current - 1]; + + /// + /// Retrieves the next variant. This must be called before reading the first element (and every subsequent + /// element). + /// + public bool MoveNext() + { + if (_current >= _variants.Count) + { + return false; + } + + _current++; + return true; + } + + /// + /// Resets the enumerator back to its initial state. Note that must be called before + /// retrieving an element again. + /// + public void Reset() => _current = 0; + } +} diff --git a/sources/Windowing/Windowing/WindowState.cs b/sources/Windowing/Windowing/WindowState.cs new file mode 100644 index 0000000000..d21893d173 --- /dev/null +++ b/sources/Windowing/Windowing/WindowState.cs @@ -0,0 +1,40 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Represents the current state of the window. +/// +public enum WindowState +{ + /// + /// The window is in its regular configuration. + /// + Normal = 0, + + /// + /// The window has been minimized to the task bar. + /// + Minimized, + + /// + /// The window has been maximized, covering the entire desktop, but not the taskbar. + /// + Maximized, + + /// + /// The window has been fullscreened, covering the entire surface of the monitor without a border, with exclusive + /// control over the display. Note that changing to/from this state may enact an implicit change to + /// 's state if supported. + /// + ExclusiveFullscreen, + + /// + /// The window has been fullscreened, covering the entire surface of the monitor, but still uses window management + /// to allow the user to interoperate with other applications easily. This setting leads the + /// setting to be ignored, as this setting is functionally equivalent to + /// and a border. + /// + WindowedFullscreen, +} diff --git a/sources/Windowing/Windowing/WindowStateEvent.cs b/sources/Windowing/Windowing/WindowStateEvent.cs new file mode 100644 index 0000000000..c5d2d437b0 --- /dev/null +++ b/sources/Windowing/Windowing/WindowStateEvent.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a change in window state. +/// +/// The surface that owns the window to which the event pertains. +/// The previous value of . +/// The new value of . +public readonly record struct WindowStateEvent( + Surface Surface, + WindowState OldState, + WindowState NewState +); diff --git a/sources/Windowing/Windowing/WindowToggleEvent.cs b/sources/Windowing/Windowing/WindowToggleEvent.cs new file mode 100644 index 0000000000..f1c76bd871 --- /dev/null +++ b/sources/Windowing/Windowing/WindowToggleEvent.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Windowing; + +/// +/// Contains properties pertaining to a boolean window property being toggled. +/// +/// The surface for which the property has been toggled. +/// The new value. +public readonly record struct WindowToggleEvent(Surface Surface, bool Value); diff --git a/sources/global.json b/sources/global.json deleted file mode 100644 index 107bbe17ba..0000000000 --- a/sources/global.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "sdk": { - "version": "8.0.100-rc.2.23502.2", - "rollForward": "latestMajor", - "allowPrerelease": true - } -} \ No newline at end of file diff --git a/tests/Core/Core/BreakneckRequestTests.cs b/tests/Core/Core/BreakneckRequestTests.cs new file mode 100644 index 0000000000..540053fa22 --- /dev/null +++ b/tests/Core/Core/BreakneckRequestTests.cs @@ -0,0 +1,121 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Core.UnitTests; + +public class BreakneckRequestTests +{ + [Test] + public void NoParams() + { + var req = new BreakneckRequest(); + + // Simulate an overflow. + Unsafe.As, int>(ref req) = int.MaxValue - 8; + Unsafe.Add(ref Unsafe.As, int>(ref req), 1) = int.MaxValue - 8; + + var barrier = new Barrier(5); + var rspCnt = 0; + for (var i = 0; i < 4; i++) + { + // var i1 = i; + new Thread(() => + { + barrier.SignalAndWait(); + for (int j = 0; j < 4; j++) + { + // Console.WriteLine($"Requesting for {i1}"); + if (req.Request() == 69) + { + // Console.WriteLine($"Got response for {i1}."); + Interlocked.Increment(ref rspCnt); + } + } + }) + { + IsBackground = true + }.Start(); + } + + barrier.SignalAndWait(); + var misses = 0; + bool missed; + for (var i = 0; i < 16; i += missed ? 0 : 1) + { + if (!req.IsRequested && misses <= int.MaxValue - 1) + { + misses++; + missed = true; + continue; + } + Assert.That(req.IsRequested, Is.True); + misses = 0; + missed = false; + // Console.WriteLine("providing"); + req.Provide(69); + } + + Thread.Sleep(50); + Assert.That(rspCnt, Is.EqualTo(16)); + Assert.That(req.IsRequested, Is.False); + } + + [Test] + public void Params() + { + var req = new BreakneckRequest(); + + // Simulate an overflow. + Unsafe.As, int>(ref req) = int.MaxValue - 8; + Unsafe.Add(ref Unsafe.As, int>(ref req), 1) = int.MaxValue - 8; + + var barrier = new Barrier(5); + var rspCnt = 0; + for (var i = 0; i < 4; i++) + { + var i1 = i; + new Thread(() => + { + barrier.SignalAndWait(); + for (var j = 0; j < 4; j++) + { + // Console.WriteLine($"Requesting for {i1}"); + if (req.Request(i1) == i1) + { + // Console.WriteLine($"Got response for {i1}."); + Interlocked.Increment(ref rspCnt); + } + } + }) + { + IsBackground = true + }.Start(); + } + + barrier.SignalAndWait(); + var misses = 0; + bool missed; + for (var i = 0; i < 16; i += missed ? 0 : 1) + { + var isRequested = req.TryGetRequest(out var echo); + if (!isRequested && misses <= int.MaxValue - 1) + { + misses++; + missed = true; + continue; + } + Assert.That(isRequested, Is.True); + misses = 0; + missed = false; + // Console.WriteLine("providing"); + req.Provide(echo); + } + + Thread.Sleep(50); + Assert.That(rspCnt, Is.EqualTo(16)); + Assert.That(req.TryGetRequest(out _), Is.False); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBlitInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBlitInfoTests.gen.cs new file mode 100644 index 0000000000..33410af066 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBlitInfoTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBlitInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBlitInfo))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBlitInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUBlitInfo), Is.EqualTo(96)); + } + else + { + Assert.That(sizeof(GPUBlitInfo), Is.EqualTo(88)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBlitRegionTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBlitRegionTests.gen.cs new file mode 100644 index 0000000000..94e245a982 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBlitRegionTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBlitRegionTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBlitRegion))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBlitRegion).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUBlitRegion), Is.EqualTo(32)); + } + else + { + Assert.That(sizeof(GPUBlitRegion), Is.EqualTo(28)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBufferBindingTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBufferBindingTests.gen.cs new file mode 100644 index 0000000000..686660979e --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBufferBindingTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBufferBindingTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBufferBinding))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBufferBinding).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUBufferBinding), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUBufferBinding), Is.EqualTo(8)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBufferCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBufferCreateInfoTests.gen.cs new file mode 100644 index 0000000000..f9f791fa1d --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBufferCreateInfoTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBufferCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBufferCreateInfo))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBufferCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUBufferCreateInfo), Is.EqualTo(12)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBufferLocationTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBufferLocationTests.gen.cs new file mode 100644 index 0000000000..59a059fb40 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBufferLocationTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBufferLocationTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBufferLocation))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBufferLocation).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUBufferLocation), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUBufferLocation), Is.EqualTo(8)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUBufferRegionTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUBufferRegionTests.gen.cs new file mode 100644 index 0000000000..56df31ff7a --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUBufferRegionTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUBufferRegionTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUBufferRegion))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUBufferRegion).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUBufferRegion), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUBufferRegion), Is.EqualTo(12)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUColorTargetBlendStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetBlendStateTests.gen.cs new file mode 100644 index 0000000000..74737cfbc3 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetBlendStateTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUColorTargetBlendStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUColorTargetBlendState)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUColorTargetBlendState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUColorTargetBlendState), Is.EqualTo(32)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUColorTargetDescriptionTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetDescriptionTests.gen.cs new file mode 100644 index 0000000000..94288a76d0 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetDescriptionTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUColorTargetDescriptionTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUColorTargetDescription)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUColorTargetDescription).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUColorTargetDescription), Is.EqualTo(36)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUColorTargetInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetInfoTests.gen.cs new file mode 100644 index 0000000000..d1bc6aa5e9 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUColorTargetInfoTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUColorTargetInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUColorTargetInfo))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUColorTargetInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUColorTargetInfo), Is.EqualTo(64)); + } + else + { + Assert.That(sizeof(GPUColorTargetInfo), Is.EqualTo(52)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUComputePipelineCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUComputePipelineCreateInfoTests.gen.cs new file mode 100644 index 0000000000..04b5b7c011 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUComputePipelineCreateInfoTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUComputePipelineCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUComputePipelineCreateInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUComputePipelineCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUComputePipelineCreateInfo), Is.EqualTo(72)); + } + else + { + Assert.That(sizeof(GPUComputePipelineCreateInfo), Is.EqualTo(56)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilStateTests.gen.cs new file mode 100644 index 0000000000..52059fd704 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilStateTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUDepthStencilStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUDepthStencilState)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUDepthStencilState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUDepthStencilState), Is.EqualTo(44)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilTargetInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilTargetInfoTests.gen.cs new file mode 100644 index 0000000000..fb283b3fb9 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUDepthStencilTargetInfoTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUDepthStencilTargetInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUDepthStencilTargetInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUDepthStencilTargetInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUDepthStencilTargetInfo), Is.EqualTo(32)); + } + else + { + Assert.That(sizeof(GPUDepthStencilTargetInfo), Is.EqualTo(28)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineCreateInfoTests.gen.cs new file mode 100644 index 0000000000..5f1d5027e0 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineCreateInfoTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUGraphicsPipelineCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUGraphicsPipelineCreateInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUGraphicsPipelineCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUGraphicsPipelineCreateInfo), Is.EqualTo(168)); + } + else + { + Assert.That(sizeof(GPUGraphicsPipelineCreateInfo), Is.EqualTo(132)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineTargetInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineTargetInfoTests.gen.cs new file mode 100644 index 0000000000..90733ba7c9 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUGraphicsPipelineTargetInfoTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUGraphicsPipelineTargetInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUGraphicsPipelineTargetInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUGraphicsPipelineTargetInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUGraphicsPipelineTargetInfo), Is.EqualTo(24)); + } + else + { + Assert.That(sizeof(GPUGraphicsPipelineTargetInfo), Is.EqualTo(16)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUIndexedIndirectDrawCommandTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUIndexedIndirectDrawCommandTests.gen.cs new file mode 100644 index 0000000000..a02e099b68 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUIndexedIndirectDrawCommandTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUIndexedIndirectDrawCommandTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUIndexedIndirectDrawCommand)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUIndexedIndirectDrawCommand).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUIndexedIndirectDrawCommand), Is.EqualTo(20)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUIndirectDispatchCommandTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUIndirectDispatchCommandTests.gen.cs new file mode 100644 index 0000000000..0a6e13751d --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUIndirectDispatchCommandTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUIndirectDispatchCommandTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUIndirectDispatchCommand)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUIndirectDispatchCommand).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUIndirectDispatchCommand), Is.EqualTo(12)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUIndirectDrawCommandTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUIndirectDrawCommandTests.gen.cs new file mode 100644 index 0000000000..768fef4202 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUIndirectDrawCommandTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUIndirectDrawCommandTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUIndirectDrawCommand)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUIndirectDrawCommand).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUIndirectDrawCommand), Is.EqualTo(16)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUMultisampleStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUMultisampleStateTests.gen.cs new file mode 100644 index 0000000000..b2eb4fbd58 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUMultisampleStateTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUMultisampleStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUMultisampleState))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUMultisampleState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUMultisampleState), Is.EqualTo(12)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPURasterizerStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPURasterizerStateTests.gen.cs new file mode 100644 index 0000000000..a1502604b1 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPURasterizerStateTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPURasterizerStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPURasterizerState))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPURasterizerState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPURasterizerState), Is.EqualTo(28)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUSamplerCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUSamplerCreateInfoTests.gen.cs new file mode 100644 index 0000000000..9fd4bb8162 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUSamplerCreateInfoTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUSamplerCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUSamplerCreateInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUSamplerCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUSamplerCreateInfo), Is.EqualTo(52)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUShaderCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUShaderCreateInfoTests.gen.cs new file mode 100644 index 0000000000..83705e6a98 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUShaderCreateInfoTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUShaderCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUShaderCreateInfo))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUShaderCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUShaderCreateInfo), Is.EqualTo(56)); + } + else + { + Assert.That(sizeof(GPUShaderCreateInfo), Is.EqualTo(40)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUStencilOpStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUStencilOpStateTests.gen.cs new file mode 100644 index 0000000000..e7a2a8b35b --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUStencilOpStateTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUStencilOpStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUStencilOpState))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUStencilOpState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUStencilOpState), Is.EqualTo(16)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUStorageBufferReadWriteBindingTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUStorageBufferReadWriteBindingTests.gen.cs new file mode 100644 index 0000000000..1d499ec4d5 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUStorageBufferReadWriteBindingTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUStorageBufferReadWriteBindingTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUStorageBufferReadWriteBinding)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUStorageBufferReadWriteBinding).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUStorageBufferReadWriteBinding), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUStorageBufferReadWriteBinding), Is.EqualTo(8)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUStorageTextureReadWriteBindingTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUStorageTextureReadWriteBindingTests.gen.cs new file mode 100644 index 0000000000..2131663a20 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUStorageTextureReadWriteBindingTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUStorageTextureReadWriteBindingTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUStorageTextureReadWriteBinding)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUStorageTextureReadWriteBinding).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUStorageTextureReadWriteBinding), Is.EqualTo(24)); + } + else + { + Assert.That(sizeof(GPUStorageTextureReadWriteBinding), Is.EqualTo(16)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTextureCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTextureCreateInfoTests.gen.cs new file mode 100644 index 0000000000..a176e0ee7a --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTextureCreateInfoTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTextureCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUTextureCreateInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTextureCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUTextureCreateInfo), Is.EqualTo(36)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTextureLocationTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTextureLocationTests.gen.cs new file mode 100644 index 0000000000..8618af8740 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTextureLocationTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTextureLocationTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUTextureLocation))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTextureLocation).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUTextureLocation), Is.EqualTo(32)); + } + else + { + Assert.That(sizeof(GPUTextureLocation), Is.EqualTo(24)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTextureRegionTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTextureRegionTests.gen.cs new file mode 100644 index 0000000000..4167376fba --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTextureRegionTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTextureRegionTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUTextureRegion))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTextureRegion).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUTextureRegion), Is.EqualTo(40)); + } + else + { + Assert.That(sizeof(GPUTextureRegion), Is.EqualTo(36)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTextureSamplerBindingTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTextureSamplerBindingTests.gen.cs new file mode 100644 index 0000000000..ed404af3fa --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTextureSamplerBindingTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTextureSamplerBindingTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUTextureSamplerBinding)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTextureSamplerBinding).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUTextureSamplerBinding), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUTextureSamplerBinding), Is.EqualTo(8)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTextureTransferInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTextureTransferInfoTests.gen.cs new file mode 100644 index 0000000000..f44563ccb5 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTextureTransferInfoTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTextureTransferInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUTextureTransferInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTextureTransferInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUTextureTransferInfo), Is.EqualTo(24)); + } + else + { + Assert.That(sizeof(GPUTextureTransferInfo), Is.EqualTo(16)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferCreateInfoTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferCreateInfoTests.gen.cs new file mode 100644 index 0000000000..d6e1d97e3b --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferCreateInfoTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTransferBufferCreateInfoTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUTransferBufferCreateInfo)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTransferBufferCreateInfo).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUTransferBufferCreateInfo), Is.EqualTo(12)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferLocationTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferLocationTests.gen.cs new file mode 100644 index 0000000000..093ec037fd --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUTransferBufferLocationTests.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUTransferBufferLocationTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUTransferBufferLocation)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUTransferBufferLocation).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUTransferBufferLocation), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(GPUTransferBufferLocation), Is.EqualTo(8)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUVertexAttributeTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUVertexAttributeTests.gen.cs new file mode 100644 index 0000000000..a3b87eeb75 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUVertexAttributeTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUVertexAttributeTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUVertexAttribute))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUVertexAttribute).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUVertexAttribute), Is.EqualTo(16)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUVertexBufferDescriptionTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUVertexBufferDescriptionTests.gen.cs new file mode 100644 index 0000000000..afba949e6a --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUVertexBufferDescriptionTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUVertexBufferDescriptionTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That( + Marshal.SizeOf(), + Is.EqualTo(sizeof(GPUVertexBufferDescription)) + ); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUVertexBufferDescription).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUVertexBufferDescription), Is.EqualTo(16)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUVertexInputStateTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUVertexInputStateTests.gen.cs new file mode 100644 index 0000000000..6351dffffc --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUVertexInputStateTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUVertexInputStateTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUVertexInputState))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUVertexInputState).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(GPUVertexInputState), Is.EqualTo(32)); + } + else + { + Assert.That(sizeof(GPUVertexInputState), Is.EqualTo(16)); + } + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_GPUViewportTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_GPUViewportTests.gen.cs new file mode 100644 index 0000000000..208830a80b --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_GPUViewportTests.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. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_GPUViewportTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(GPUViewport))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(GPUViewport).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + Assert.That(sizeof(GPUViewport), Is.EqualTo(24)); + } +} diff --git a/tests/SDL/SDL/SDL3/SDL_alignment_testTests.gen.cs b/tests/SDL/SDL/SDL3/SDL_alignment_testTests.gen.cs new file mode 100644 index 0000000000..45f912c9d7 --- /dev/null +++ b/tests/SDL/SDL/SDL3/SDL_alignment_testTests.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// Ported from SDL.h and corresponding dependencies of SDL3. +// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license. +using System; +using System.Runtime.InteropServices; +using NUnit.Framework; + +namespace Silk.NET.SDL.UnitTests; + +/// Provides validation of the struct. +public static unsafe partial class SDL_alignment_testTests +{ + /// Validates that the struct is blittable. + + [Test] + public static void IsBlittableTest() + { + Assert.That(Marshal.SizeOf(), Is.EqualTo(sizeof(AlignmentTest))); + } + + /// Validates that the struct has the right . + + [Test] + public static void IsLayoutSequentialTest() + { + Assert.That(typeof(AlignmentTest).IsLayoutSequential, Is.True); + } + + /// Validates that the struct has the correct size. + + [Test] + public static void SizeOfTest() + { + if (Environment.Is64BitProcess) + { + Assert.That(sizeof(AlignmentTest), Is.EqualTo(16)); + } + else + { + Assert.That(sizeof(AlignmentTest), Is.EqualTo(8)); + } + } +}